// $ANTLR 3.2 Sep 23, 2009 12:02:23 C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g 2011-10-04 18:38:21

// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162


using System;
using Antlr.Runtime;
using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;



using Antlr.Runtime.Tree;
using SwimmingCompetition.Exceptions;

namespace 
    SwimmingCompetition

{
public partial class SwimmingCompetitionGrammarParser : Parser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"EVENT", 
		"INFOEVENT", 
		"NAMEEVENT", 
		"CATEGORY", 
		"CATP", 
		"CATA", 
		"CATM", 
		"ORGANIZ", 
		"LOCATION", 
		"TYPE", 
		"START", 
		"END", 
		"ENDDATEREG", 
		"POOLBASE", 
		"LIMITTIMEREG", 
		"LANES", 
		"JURY", 
		"REFEREE", 
		"COADJUTOR", 
		"DEPJUDGE", 
		"FALSESTARTEMPL", 
		"COMPEMPL", 
		"TIMING", 
		"CRONOTYPE", 
		"CRONOSERV", 
		"CRONOSOC", 
		"OTHER", 
		"SPEAK", 
		"DOCT", 
		"MANAG", 
		"PROG", 
		"DATECOMP", 
		"HOURCOMP", 
		"CATEGORYCOMP", 
		"TYPEESA", 
		"TYPEESB", 
		"TYPEP1", 
		"TYPEP2", 
		"TYPEP3", 
		"TYPEP4", 
		"TYPEP5", 
		"TYPEP6", 
		"TYPEP7", 
		"TYPER", 
		"TYPEJ", 
		"TYPEC", 
		"TYPES", 
		"TYPEABS", 
		"TYPEU25", 
		"TYPEM25", 
		"TYPEM30", 
		"TYPEM35", 
		"TYPEM40", 
		"TYPEM45", 
		"TYPEM50", 
		"TYPEM55", 
		"TYPEM60", 
		"TYPEM65", 
		"SPECCOMP", 
		"TURNCOMP", 
		"HEATS", 
		"FIN", 
		"SEMFIN", 
		"STARTLIST", 
		"COMPNAME", 
		"ATHLETE", 
		"LANE", 
		"NOTES", 
		"ACODE", 
		"ANAME", 
		"ASURNNAME", 
		"ASOC", 
		"ABIRTH", 
		"ATIMEREG", 
		"ATIMERES", 
		"A_GR", 
		"C_GR", 
		"A_Q", 
		"C_Q", 
		"DECDIGIT", 
		"DIGIT", 
		"ATIME", 
		"INT", 
		"FLOAT", 
		"DATE", 
		"HOUR", 
		"ESC_SEQ", 
		"STRING", 
		"HEX_DIGIT", 
		"UNICODE_ESC", 
		"OCTAL_ESC", 
		"COMMENT", 
		"WS", 
		"':'", 
		"'m'"
    };

    public const int TYPEC = 49;
    public const int OCTAL_ESC = 94;
    public const int TYPES = 50;
    public const int TYPER = 47;
    public const int EOF = -1;
    public const int COADJUTOR = 22;
    public const int TYPEJ = 48;
    public const int FIN = 65;
    public const int TYPE = 13;
    public const int CRONOSOC = 29;
    public const int TYPEM60 = 60;
    public const int A_GR = 79;
    public const int ASOC = 75;
    public const int COMMENT = 95;
    public const int ORGANIZ = 11;
    public const int TYPEM65 = 61;
    public const int DEPJUDGE = 23;
    public const int T__98 = 98;
    public const int CRONOSERV = 28;
    public const int T__97 = 97;
    public const int C_Q = 82;
    public const int TYPEM50 = 58;
    public const int TURNCOMP = 63;
    public const int ANAME = 73;
    public const int TYPEESA = 38;
    public const int TYPEESB = 39;
    public const int CATEGORY = 7;
    public const int INT = 86;
    public const int TYPEP7 = 46;
    public const int DECDIGIT = 83;
    public const int ENDDATEREG = 16;
    public const int TYPEP6 = 45;
    public const int TYPEM55 = 59;
    public const int CRONOTYPE = 27;
    public const int TYPEM40 = 56;
    public const int TYPEP1 = 40;
    public const int CATP = 8;
    public const int ATIME = 85;
    public const int WS = 96;
    public const int TYPEP2 = 41;
    public const int TYPEP3 = 42;
    public const int TYPEP4 = 43;
    public const int C_GR = 80;
    public const int TYPEP5 = 44;
    public const int ATIMEREG = 77;
    public const int CATM = 10;
    public const int LOCATION = 12;
    public const int CATA = 9;
    public const int END = 15;
    public const int ATIMERES = 78;
    public const int TYPEM45 = 57;
    public const int LANE = 70;
    public const int COMPEMPL = 25;
    public const int TYPEM25 = 53;
    public const int ACODE = 72;
    public const int DOCT = 32;
    public const int ABIRTH = 76;
    public const int FLOAT = 87;
    public const int FALSESTARTEMPL = 24;
    public const int TIMING = 26;
    public const int SEMFIN = 66;
    public const int TYPEM35 = 55;
    public const int PROG = 34;
    public const int ESC_SEQ = 90;
    public const int TYPEU25 = 52;
    public const int TYPEM30 = 54;
    public const int HEATS = 64;
    public const int TYPEABS = 51;
    public const int DIGIT = 84;
    public const int CATEGORYCOMP = 37;
    public const int ASURNNAME = 74;
    public const int OTHER = 30;
    public const int SPECCOMP = 62;
    public const int JURY = 20;
    public const int UNICODE_ESC = 93;
    public const int ATHLETE = 69;
    public const int POOLBASE = 17;
    public const int HEX_DIGIT = 92;
    public const int SPEAK = 31;
    public const int EVENT = 4;
    public const int HOUR = 89;
    public const int REFEREE = 21;
    public const int STARTLIST = 67;
    public const int NOTES = 71;
    public const int A_Q = 81;
    public const int INFOEVENT = 5;
    public const int LANES = 19;
    public const int DATECOMP = 35;
    public const int COMPNAME = 68;
    public const int LIMITTIMEREG = 18;
    public const int NAMEEVENT = 6;
    public const int HOURCOMP = 36;
    public const int START = 14;
    public const int MANAG = 33;
    public const int DATE = 88;
    public const int STRING = 91;

    // delegates
    // delegators



        public SwimmingCompetitionGrammarParser(ITokenStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public SwimmingCompetitionGrammarParser(ITokenStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }
        
    protected ITreeAdaptor adaptor = new CommonTreeAdaptor();

    public ITreeAdaptor TreeAdaptor
    {
        get { return this.adaptor; }
        set {
    	this.adaptor = value;
    	}
    }

    override public string[] TokenNames {
		get { return SwimmingCompetitionGrammarParser.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g"; }
    }


    public class s_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "s"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:160:1: s : EVENT A_GR infocompetition jurycronoother programcomp startlist note C_GR -> ^( EVENT infocompetition jurycronoother programcomp startlist note ) ;
    public SwimmingCompetitionGrammarParser.s_return s() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.s_return retval = new SwimmingCompetitionGrammarParser.s_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken EVENT1 = null;
        IToken A_GR2 = null;
        IToken C_GR8 = null;
        SwimmingCompetitionGrammarParser.infocompetition_return infocompetition3 = default(SwimmingCompetitionGrammarParser.infocompetition_return);

        SwimmingCompetitionGrammarParser.jurycronoother_return jurycronoother4 = default(SwimmingCompetitionGrammarParser.jurycronoother_return);

        SwimmingCompetitionGrammarParser.programcomp_return programcomp5 = default(SwimmingCompetitionGrammarParser.programcomp_return);

        SwimmingCompetitionGrammarParser.startlist_return startlist6 = default(SwimmingCompetitionGrammarParser.startlist_return);

        SwimmingCompetitionGrammarParser.note_return note7 = default(SwimmingCompetitionGrammarParser.note_return);


        CommonTree EVENT1_tree=null;
        CommonTree A_GR2_tree=null;
        CommonTree C_GR8_tree=null;
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleTokenStream stream_EVENT = new RewriteRuleTokenStream(adaptor,"token EVENT");
        RewriteRuleSubtreeStream stream_infocompetition = new RewriteRuleSubtreeStream(adaptor,"rule infocompetition");
        RewriteRuleSubtreeStream stream_programcomp = new RewriteRuleSubtreeStream(adaptor,"rule programcomp");
        RewriteRuleSubtreeStream stream_startlist = new RewriteRuleSubtreeStream(adaptor,"rule startlist");
        RewriteRuleSubtreeStream stream_jurycronoother = new RewriteRuleSubtreeStream(adaptor,"rule jurycronoother");
        RewriteRuleSubtreeStream stream_note = new RewriteRuleSubtreeStream(adaptor,"rule note");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:160:2: ( EVENT A_GR infocompetition jurycronoother programcomp startlist note C_GR -> ^( EVENT infocompetition jurycronoother programcomp startlist note ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:160:4: EVENT A_GR infocompetition jurycronoother programcomp startlist note C_GR
            {
            	EVENT1=(IToken)Match(input,EVENT,FOLLOW_EVENT_in_s1088);  
            	stream_EVENT.Add(EVENT1);

            	A_GR2=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_s1090);  
            	stream_A_GR.Add(A_GR2);

            	PushFollow(FOLLOW_infocompetition_in_s1092);
            	infocompetition3 = infocompetition();
            	state.followingStackPointer--;

            	stream_infocompetition.Add(infocompetition3.Tree);
            	PushFollow(FOLLOW_jurycronoother_in_s1094);
            	jurycronoother4 = jurycronoother();
            	state.followingStackPointer--;

            	stream_jurycronoother.Add(jurycronoother4.Tree);
            	PushFollow(FOLLOW_programcomp_in_s1096);
            	programcomp5 = programcomp();
            	state.followingStackPointer--;

            	stream_programcomp.Add(programcomp5.Tree);
            	PushFollow(FOLLOW_startlist_in_s1098);
            	startlist6 = startlist();
            	state.followingStackPointer--;

            	stream_startlist.Add(startlist6.Tree);
            	PushFollow(FOLLOW_note_in_s1100);
            	note7 = note();
            	state.followingStackPointer--;

            	stream_note.Add(note7.Tree);
            	C_GR8=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_s1102);  
            	stream_C_GR.Add(C_GR8);



            	// AST REWRITE
            	// elements:          EVENT, startlist, programcomp, infocompetition, jurycronoother, note
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 161:2: -> ^( EVENT infocompetition jurycronoother programcomp startlist note )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:161:5: ^( EVENT infocompetition jurycronoother programcomp startlist note )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.EventNode(stream_EVENT.NextToken()), root_1);

            	    adaptor.AddChild(root_1, stream_infocompetition.NextTree());
            	    adaptor.AddChild(root_1, stream_jurycronoother.NextTree());
            	    adaptor.AddChild(root_1, stream_programcomp.NextTree());
            	    adaptor.AddChild(root_1, stream_startlist.NextTree());
            	    adaptor.AddChild(root_1, stream_note.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	    retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
            throw new ErrorNodeException("ErrorNodeException", "^( EVENT infocompetition jurycronoother programcomp startlist note )");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "s"

    public class infocompetition_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "infocompetition"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:163:1: infocompetition : INFOEVENT A_GR nameevent category organiz location type start end enddatereg poolbase limittimereg lanes C_GR -> ^( INFOEVENT nameevent category organiz location type start end enddatereg poolbase limittimereg lanes ) ;
    public SwimmingCompetitionGrammarParser.infocompetition_return infocompetition() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.infocompetition_return retval = new SwimmingCompetitionGrammarParser.infocompetition_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken INFOEVENT9 = null;
        IToken A_GR10 = null;
        IToken C_GR22 = null;
        SwimmingCompetitionGrammarParser.nameevent_return nameevent11 = default(SwimmingCompetitionGrammarParser.nameevent_return);

        SwimmingCompetitionGrammarParser.category_return category12 = default(SwimmingCompetitionGrammarParser.category_return);

        SwimmingCompetitionGrammarParser.organiz_return organiz13 = default(SwimmingCompetitionGrammarParser.organiz_return);

        SwimmingCompetitionGrammarParser.location_return location14 = default(SwimmingCompetitionGrammarParser.location_return);

        SwimmingCompetitionGrammarParser.type_return type15 = default(SwimmingCompetitionGrammarParser.type_return);

        SwimmingCompetitionGrammarParser.start_return start16 = default(SwimmingCompetitionGrammarParser.start_return);

        SwimmingCompetitionGrammarParser.end_return end17 = default(SwimmingCompetitionGrammarParser.end_return);

        SwimmingCompetitionGrammarParser.enddatereg_return enddatereg18 = default(SwimmingCompetitionGrammarParser.enddatereg_return);

        SwimmingCompetitionGrammarParser.poolbase_return poolbase19 = default(SwimmingCompetitionGrammarParser.poolbase_return);

        SwimmingCompetitionGrammarParser.limittimereg_return limittimereg20 = default(SwimmingCompetitionGrammarParser.limittimereg_return);

        SwimmingCompetitionGrammarParser.lanes_return lanes21 = default(SwimmingCompetitionGrammarParser.lanes_return);


        CommonTree INFOEVENT9_tree=null;
        CommonTree A_GR10_tree=null;
        CommonTree C_GR22_tree=null;
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleTokenStream stream_INFOEVENT = new RewriteRuleTokenStream(adaptor,"token INFOEVENT");
        RewriteRuleSubtreeStream stream_category = new RewriteRuleSubtreeStream(adaptor,"rule category");
        RewriteRuleSubtreeStream stream_nameevent = new RewriteRuleSubtreeStream(adaptor,"rule nameevent");
        RewriteRuleSubtreeStream stream_poolbase = new RewriteRuleSubtreeStream(adaptor,"rule poolbase");
        RewriteRuleSubtreeStream stream_location = new RewriteRuleSubtreeStream(adaptor,"rule location");
        RewriteRuleSubtreeStream stream_start = new RewriteRuleSubtreeStream(adaptor,"rule start");
        RewriteRuleSubtreeStream stream_limittimereg = new RewriteRuleSubtreeStream(adaptor,"rule limittimereg");
        RewriteRuleSubtreeStream stream_organiz = new RewriteRuleSubtreeStream(adaptor,"rule organiz");
        RewriteRuleSubtreeStream stream_enddatereg = new RewriteRuleSubtreeStream(adaptor,"rule enddatereg");
        RewriteRuleSubtreeStream stream_type = new RewriteRuleSubtreeStream(adaptor,"rule type");
        RewriteRuleSubtreeStream stream_end = new RewriteRuleSubtreeStream(adaptor,"rule end");
        RewriteRuleSubtreeStream stream_lanes = new RewriteRuleSubtreeStream(adaptor,"rule lanes");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:164:2: ( INFOEVENT A_GR nameevent category organiz location type start end enddatereg poolbase limittimereg lanes C_GR -> ^( INFOEVENT nameevent category organiz location type start end enddatereg poolbase limittimereg lanes ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:165:2: INFOEVENT A_GR nameevent category organiz location type start end enddatereg poolbase limittimereg lanes C_GR
            {
            	INFOEVENT9=(IToken)Match(input,INFOEVENT,FOLLOW_INFOEVENT_in_infocompetition1137);  
            	stream_INFOEVENT.Add(INFOEVENT9);

            	A_GR10=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_infocompetition1140);  
            	stream_A_GR.Add(A_GR10);

            	PushFollow(FOLLOW_nameevent_in_infocompetition1144);
            	nameevent11 = nameevent();
            	state.followingStackPointer--;

            	stream_nameevent.Add(nameevent11.Tree);
            	PushFollow(FOLLOW_category_in_infocompetition1147);
            	category12 = category();
            	state.followingStackPointer--;

            	stream_category.Add(category12.Tree);
            	PushFollow(FOLLOW_organiz_in_infocompetition1150);
            	organiz13 = organiz();
            	state.followingStackPointer--;

            	stream_organiz.Add(organiz13.Tree);
            	PushFollow(FOLLOW_location_in_infocompetition1153);
            	location14 = location();
            	state.followingStackPointer--;

            	stream_location.Add(location14.Tree);
            	PushFollow(FOLLOW_type_in_infocompetition1156);
            	type15 = type();
            	state.followingStackPointer--;

            	stream_type.Add(type15.Tree);
            	PushFollow(FOLLOW_start_in_infocompetition1159);
            	start16 = start();
            	state.followingStackPointer--;

            	stream_start.Add(start16.Tree);
            	PushFollow(FOLLOW_end_in_infocompetition1162);
            	end17 = end();
            	state.followingStackPointer--;

            	stream_end.Add(end17.Tree);
            	PushFollow(FOLLOW_enddatereg_in_infocompetition1165);
            	enddatereg18 = enddatereg();
            	state.followingStackPointer--;

            	stream_enddatereg.Add(enddatereg18.Tree);
            	PushFollow(FOLLOW_poolbase_in_infocompetition1168);
            	poolbase19 = poolbase();
            	state.followingStackPointer--;

            	stream_poolbase.Add(poolbase19.Tree);
            	PushFollow(FOLLOW_limittimereg_in_infocompetition1171);
            	limittimereg20 = limittimereg();
            	state.followingStackPointer--;

            	stream_limittimereg.Add(limittimereg20.Tree);
            	PushFollow(FOLLOW_lanes_in_infocompetition1174);
            	lanes21 = lanes();
            	state.followingStackPointer--;

            	stream_lanes.Add(lanes21.Tree);
            	C_GR22=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_infocompetition1177);  
            	stream_C_GR.Add(C_GR22);



            	// AST REWRITE
            	// elements:          enddatereg, category, limittimereg, organiz, nameevent, lanes, start, type, location, INFOEVENT, poolbase, end
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 179:2: -> ^( INFOEVENT nameevent category organiz location type start end enddatereg poolbase limittimereg lanes )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:179:5: ^( INFOEVENT nameevent category organiz location type start end enddatereg poolbase limittimereg lanes )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.InfoEventNode(stream_INFOEVENT.NextToken()), root_1);

            	    adaptor.AddChild(root_1, stream_nameevent.NextTree());
            	    adaptor.AddChild(root_1, stream_category.NextTree());
            	    adaptor.AddChild(root_1, stream_organiz.NextTree());
            	    adaptor.AddChild(root_1, stream_location.NextTree());
            	    adaptor.AddChild(root_1, stream_type.NextTree());
            	    adaptor.AddChild(root_1, stream_start.NextTree());
            	    adaptor.AddChild(root_1, stream_end.NextTree());
            	    adaptor.AddChild(root_1, stream_enddatereg.NextTree());
            	    adaptor.AddChild(root_1, stream_poolbase.NextTree());
            	    adaptor.AddChild(root_1, stream_limittimereg.NextTree());
            	    adaptor.AddChild(root_1, stream_lanes.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("ErrorNodeException", "^( INFOEVENT nameevent category organiz location type start end enddatereg poolbase limittimereg lanes )");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "infocompetition"

    public class nameevent_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "nameevent"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:181:1: nameevent : NAMEEVENT ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.nameevent_return nameevent() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.nameevent_return retval = new SwimmingCompetitionGrammarParser.nameevent_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken NAMEEVENT23 = null;
        IToken char_literal24 = null;
        IToken STRING25 = null;

        CommonTree NAMEEVENT23_tree=null;
        CommonTree char_literal24_tree=null;
        CommonTree STRING25_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_NAMEEVENT = new RewriteRuleTokenStream(adaptor,"token NAMEEVENT");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:182:2: ( NAMEEVENT ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:182:4: NAMEEVENT ':' STRING
            {
            	NAMEEVENT23=(IToken)Match(input,NAMEEVENT,FOLLOW_NAMEEVENT_in_nameevent1224);  
            	stream_NAMEEVENT.Add(NAMEEVENT23);

            	char_literal24=(IToken)Match(input,97,FOLLOW_97_in_nameevent1226);  
            	stream_97.Add(char_literal24);

            	STRING25=(IToken)Match(input,STRING,FOLLOW_STRING_in_nameevent1228);  
            	stream_STRING.Add(STRING25);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 182:25: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:182:28: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.NameCompetitionNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "NAMEEVENT");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "nameevent"

    public class category_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "category"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:183:1: category : CATEGORY ':' categorySigleComp ;
    public SwimmingCompetitionGrammarParser.category_return category() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.category_return retval = new SwimmingCompetitionGrammarParser.category_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken CATEGORY26 = null;
        IToken char_literal27 = null;
        SwimmingCompetitionGrammarParser.categorySigleComp_return categorySigleComp28 = default(SwimmingCompetitionGrammarParser.categorySigleComp_return);


        CommonTree CATEGORY26_tree=null;
        CommonTree char_literal27_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:184:2: ( CATEGORY ':' categorySigleComp )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:184:4: CATEGORY ':' categorySigleComp
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	CATEGORY26=(IToken)Match(input,CATEGORY,FOLLOW_CATEGORY_in_category1249); 
            	char_literal27=(IToken)Match(input,97,FOLLOW_97_in_category1252); 
            	PushFollow(FOLLOW_categorySigleComp_in_category1255);
            	categorySigleComp28 = categorySigleComp();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, categorySigleComp28.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("","CATEGORY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "category"

    public class organiz_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "organiz"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:185:1: organiz : ORGANIZ ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.organiz_return organiz() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.organiz_return retval = new SwimmingCompetitionGrammarParser.organiz_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ORGANIZ29 = null;
        IToken char_literal30 = null;
        IToken STRING31 = null;

        CommonTree ORGANIZ29_tree=null;
        CommonTree char_literal30_tree=null;
        CommonTree STRING31_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_ORGANIZ = new RewriteRuleTokenStream(adaptor,"token ORGANIZ");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:185:9: ( ORGANIZ ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:185:11: ORGANIZ ':' STRING
            {
            	ORGANIZ29=(IToken)Match(input,ORGANIZ,FOLLOW_ORGANIZ_in_organiz1262);  
            	stream_ORGANIZ.Add(ORGANIZ29);

            	char_literal30=(IToken)Match(input,97,FOLLOW_97_in_organiz1264);  
            	stream_97.Add(char_literal30);

            	STRING31=(IToken)Match(input,STRING,FOLLOW_STRING_in_organiz1266);  
            	stream_STRING.Add(STRING31);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 185:30: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:185:33: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.OrganizationNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("","ORGANIZ");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "organiz"

    public class location_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "location"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:186:1: location : LOCATION ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.location_return location() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.location_return retval = new SwimmingCompetitionGrammarParser.location_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken LOCATION32 = null;
        IToken char_literal33 = null;
        IToken STRING34 = null;

        CommonTree LOCATION32_tree=null;
        CommonTree char_literal33_tree=null;
        CommonTree STRING34_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_LOCATION = new RewriteRuleTokenStream(adaptor,"token LOCATION");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:186:9: ( LOCATION ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:186:12: LOCATION ':' STRING
            {
            	LOCATION32=(IToken)Match(input,LOCATION,FOLLOW_LOCATION_in_location1286);  
            	stream_LOCATION.Add(LOCATION32);

            	char_literal33=(IToken)Match(input,97,FOLLOW_97_in_location1288);  
            	stream_97.Add(char_literal33);

            	STRING34=(IToken)Match(input,STRING,FOLLOW_STRING_in_location1290);  
            	stream_STRING.Add(STRING34);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 186:32: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:186:35: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.LocationNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("","LOCATION");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "location"

    public class type_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "type"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:187:1: type : TYPE ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.type_return type() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.type_return retval = new SwimmingCompetitionGrammarParser.type_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPE35 = null;
        IToken char_literal36 = null;
        IToken STRING37 = null;

        CommonTree TYPE35_tree=null;
        CommonTree char_literal36_tree=null;
        CommonTree STRING37_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_TYPE = new RewriteRuleTokenStream(adaptor,"token TYPE");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:187:6: ( TYPE ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:187:8: TYPE ':' STRING
            {
            	TYPE35=(IToken)Match(input,TYPE,FOLLOW_TYPE_in_type1310);  
            	stream_TYPE.Add(TYPE35);

            	char_literal36=(IToken)Match(input,97,FOLLOW_97_in_type1312);  
            	stream_97.Add(char_literal36);

            	STRING37=(IToken)Match(input,STRING,FOLLOW_STRING_in_type1314);  
            	stream_STRING.Add(STRING37);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 187:24: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:187:27: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.TypeNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("","TYPE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "type"

    public class start_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "start"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:188:1: start : START ':' DATE -> ^( DATE ) ;
    public SwimmingCompetitionGrammarParser.start_return start() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.start_return retval = new SwimmingCompetitionGrammarParser.start_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken START38 = null;
        IToken char_literal39 = null;
        IToken DATE40 = null;

        CommonTree START38_tree=null;
        CommonTree char_literal39_tree=null;
        CommonTree DATE40_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_START = new RewriteRuleTokenStream(adaptor,"token START");
        RewriteRuleTokenStream stream_DATE = new RewriteRuleTokenStream(adaptor,"token DATE");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:188:7: ( START ':' DATE -> ^( DATE ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:188:9: START ':' DATE
            {
            	START38=(IToken)Match(input,START,FOLLOW_START_in_start1334);  
            	stream_START.Add(START38);

            	char_literal39=(IToken)Match(input,97,FOLLOW_97_in_start1336);  
            	stream_97.Add(char_literal39);

            	DATE40=(IToken)Match(input,DATE,FOLLOW_DATE_in_start1338);  
            	stream_DATE.Add(DATE40);



            	// AST REWRITE
            	// elements:          DATE
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 188:24: -> ^( DATE )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:188:27: ^( DATE )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.StartNode(stream_DATE.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("","STARTDATE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "start"

    public class end_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "end"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:189:1: end : END ':' DATE -> ^( DATE ) ;
    public SwimmingCompetitionGrammarParser.end_return end() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.end_return retval = new SwimmingCompetitionGrammarParser.end_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken END41 = null;
        IToken char_literal42 = null;
        IToken DATE43 = null;

        CommonTree END41_tree=null;
        CommonTree char_literal42_tree=null;
        CommonTree DATE43_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_END = new RewriteRuleTokenStream(adaptor,"token END");
        RewriteRuleTokenStream stream_DATE = new RewriteRuleTokenStream(adaptor,"token DATE");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:189:5: ( END ':' DATE -> ^( DATE ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:189:7: END ':' DATE
            {
            	END41=(IToken)Match(input,END,FOLLOW_END_in_end1358);  
            	stream_END.Add(END41);

            	char_literal42=(IToken)Match(input,97,FOLLOW_97_in_end1360);  
            	stream_97.Add(char_literal42);

            	DATE43=(IToken)Match(input,DATE,FOLLOW_DATE_in_end1361);  
            	stream_DATE.Add(DATE43);



            	// AST REWRITE
            	// elements:          DATE
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 189:19: -> ^( DATE )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:189:23: ^( DATE )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.EndNode(stream_DATE.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("","ENDDATE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "end"

    public class enddatereg_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "enddatereg"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:190:1: enddatereg : ENDDATEREG ':' DATE -> ^( DATE ) ;
    public SwimmingCompetitionGrammarParser.enddatereg_return enddatereg() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.enddatereg_return retval = new SwimmingCompetitionGrammarParser.enddatereg_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ENDDATEREG44 = null;
        IToken char_literal45 = null;
        IToken DATE46 = null;

        CommonTree ENDDATEREG44_tree=null;
        CommonTree char_literal45_tree=null;
        CommonTree DATE46_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_DATE = new RewriteRuleTokenStream(adaptor,"token DATE");
        RewriteRuleTokenStream stream_ENDDATEREG = new RewriteRuleTokenStream(adaptor,"token ENDDATEREG");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:191:2: ( ENDDATEREG ':' DATE -> ^( DATE ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:191:4: ENDDATEREG ':' DATE
            {
            	ENDDATEREG44=(IToken)Match(input,ENDDATEREG,FOLLOW_ENDDATEREG_in_enddatereg1383);  
            	stream_ENDDATEREG.Add(ENDDATEREG44);

            	char_literal45=(IToken)Match(input,97,FOLLOW_97_in_enddatereg1385);  
            	stream_97.Add(char_literal45);

            	DATE46=(IToken)Match(input,DATE,FOLLOW_DATE_in_enddatereg1387);  
            	stream_DATE.Add(DATE46);



            	// AST REWRITE
            	// elements:          DATE
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 191:24: -> ^( DATE )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:191:27: ^( DATE )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.EndDateRegNode(stream_DATE.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "ENDDATEREG");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "enddatereg"

    public class poolbase_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "poolbase"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:192:1: poolbase : POOLBASE ':' INT 'm' -> ^( INT ) ;
    public SwimmingCompetitionGrammarParser.poolbase_return poolbase() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.poolbase_return retval = new SwimmingCompetitionGrammarParser.poolbase_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken POOLBASE47 = null;
        IToken char_literal48 = null;
        IToken INT49 = null;
        IToken char_literal50 = null;

        CommonTree POOLBASE47_tree=null;
        CommonTree char_literal48_tree=null;
        CommonTree INT49_tree=null;
        CommonTree char_literal50_tree=null;
        RewriteRuleTokenStream stream_98 = new RewriteRuleTokenStream(adaptor,"token 98");
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_POOLBASE = new RewriteRuleTokenStream(adaptor,"token POOLBASE");
        RewriteRuleTokenStream stream_INT = new RewriteRuleTokenStream(adaptor,"token INT");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:192:9: ( POOLBASE ':' INT 'm' -> ^( INT ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:192:11: POOLBASE ':' INT 'm'
            {
            	POOLBASE47=(IToken)Match(input,POOLBASE,FOLLOW_POOLBASE_in_poolbase1406);  
            	stream_POOLBASE.Add(POOLBASE47);

            	char_literal48=(IToken)Match(input,97,FOLLOW_97_in_poolbase1408);  
            	stream_97.Add(char_literal48);

            	INT49=(IToken)Match(input,INT,FOLLOW_INT_in_poolbase1410);  
            	stream_INT.Add(INT49);

            	char_literal50=(IToken)Match(input,98,FOLLOW_98_in_poolbase1412);  
            	stream_98.Add(char_literal50);



            	// AST REWRITE
            	// elements:          INT
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 192:32: -> ^( INT )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:192:35: ^( INT )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.PoolBaseNode(stream_INT.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "POOLBASE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "poolbase"

    public class limittimereg_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "limittimereg"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:193:1: limittimereg : LIMITTIMEREG ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.limittimereg_return limittimereg() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.limittimereg_return retval = new SwimmingCompetitionGrammarParser.limittimereg_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken LIMITTIMEREG51 = null;
        IToken char_literal52 = null;
        IToken STRING53 = null;

        CommonTree LIMITTIMEREG51_tree=null;
        CommonTree char_literal52_tree=null;
        CommonTree STRING53_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_LIMITTIMEREG = new RewriteRuleTokenStream(adaptor,"token LIMITTIMEREG");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:194:2: ( LIMITTIMEREG ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:194:5: LIMITTIMEREG ':' STRING
            {
            	LIMITTIMEREG51=(IToken)Match(input,LIMITTIMEREG,FOLLOW_LIMITTIMEREG_in_limittimereg1434);  
            	stream_LIMITTIMEREG.Add(LIMITTIMEREG51);

            	char_literal52=(IToken)Match(input,97,FOLLOW_97_in_limittimereg1436);  
            	stream_97.Add(char_literal52);

            	STRING53=(IToken)Match(input,STRING,FOLLOW_STRING_in_limittimereg1438);  
            	stream_STRING.Add(STRING53);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 194:29: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:194:32: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.LimitTimeRegNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "LIMITTIMEREG");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "limittimereg"

    public class lanes_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "lanes"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:195:1: lanes : LANES ':' INT -> ^( INT ) ;
    public SwimmingCompetitionGrammarParser.lanes_return lanes() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.lanes_return retval = new SwimmingCompetitionGrammarParser.lanes_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken LANES54 = null;
        IToken char_literal55 = null;
        IToken INT56 = null;

        CommonTree LANES54_tree=null;
        CommonTree char_literal55_tree=null;
        CommonTree INT56_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_LANES = new RewriteRuleTokenStream(adaptor,"token LANES");
        RewriteRuleTokenStream stream_INT = new RewriteRuleTokenStream(adaptor,"token INT");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:195:7: ( LANES ':' INT -> ^( INT ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:195:9: LANES ':' INT
            {
            	LANES54=(IToken)Match(input,LANES,FOLLOW_LANES_in_lanes1458);  
            	stream_LANES.Add(LANES54);

            	char_literal55=(IToken)Match(input,97,FOLLOW_97_in_lanes1460);  
            	stream_97.Add(char_literal55);

            	INT56=(IToken)Match(input,INT,FOLLOW_INT_in_lanes1462);  
            	stream_INT.Add(INT56);



            	// AST REWRITE
            	// elements:          INT
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 195:23: -> ^( INT )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:195:27: ^( INT )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.LanesNode(stream_INT.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "LANES");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "lanes"

    public class categorySigleComp_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "categorySigleComp"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:197:1: categorySigleComp : ( catSA | catSM | catSP );
    public SwimmingCompetitionGrammarParser.categorySigleComp_return categorySigleComp() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.categorySigleComp_return retval = new SwimmingCompetitionGrammarParser.categorySigleComp_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        SwimmingCompetitionGrammarParser.catSA_return catSA57 = default(SwimmingCompetitionGrammarParser.catSA_return);

        SwimmingCompetitionGrammarParser.catSM_return catSM58 = default(SwimmingCompetitionGrammarParser.catSM_return);

        SwimmingCompetitionGrammarParser.catSP_return catSP59 = default(SwimmingCompetitionGrammarParser.catSP_return);



        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:197:18: ( catSA | catSM | catSP )
            int alt1 = 3;
            switch ( input.LA(1) ) 
            {
            case CATA:
            	{
                alt1 = 1;
                }
                break;
            case CATM:
            	{
                alt1 = 2;
                }
                break;
            case CATP:
            	{
                alt1 = 3;
                }
                break;
            	default:
            	    NoViableAltException nvae_d1s0 =
            	        new NoViableAltException("", 1, 0, input);

            	    throw nvae_d1s0;
            }

            switch (alt1) 
            {
                case 1 :
                    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:197:20: catSA
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_catSA_in_categorySigleComp1483);
                    	catSA57 = catSA();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, catSA57.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:197:26: catSM
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_catSM_in_categorySigleComp1485);
                    	catSM58 = catSM();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, catSM58.Tree);

                    }
                    break;
                case 3 :
                    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:197:32: catSP
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_catSP_in_categorySigleComp1487);
                    	catSP59 = catSP();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, catSP59.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "categorySigleComp"

    public class catSA_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "catSA"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:199:1: catSA : CATA ;
    public SwimmingCompetitionGrammarParser.catSA_return catSA() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.catSA_return retval = new SwimmingCompetitionGrammarParser.catSA_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken CATA60 = null;

        CommonTree CATA60_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:199:7: ( CATA )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:199:9: CATA
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	CATA60=(IToken)Match(input,CATA,FOLLOW_CATA_in_catSA1495); 
            		CATA60_tree = new SwimmingCompetition.AST.CategoryNode(CATA60) ;
            		adaptor.AddChild(root_0, CATA60_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "catSA"

    public class catSM_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "catSM"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:200:1: catSM : CATM ;
    public SwimmingCompetitionGrammarParser.catSM_return catSM() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.catSM_return retval = new SwimmingCompetitionGrammarParser.catSM_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken CATM61 = null;

        CommonTree CATM61_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:200:7: ( CATM )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:200:9: CATM
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	CATM61=(IToken)Match(input,CATM,FOLLOW_CATM_in_catSM1509); 
            		CATM61_tree = new SwimmingCompetition.AST.CategoryNode(CATM61) ;
            		adaptor.AddChild(root_0, CATM61_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "catSM"

    public class catSP_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "catSP"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:201:1: catSP : CATP ;
    public SwimmingCompetitionGrammarParser.catSP_return catSP() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.catSP_return retval = new SwimmingCompetitionGrammarParser.catSP_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken CATP62 = null;

        CommonTree CATP62_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:201:7: ( CATP )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:201:9: CATP
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	CATP62=(IToken)Match(input,CATP,FOLLOW_CATP_in_catSP1523); 
            		CATP62_tree = new SwimmingCompetition.AST.CategoryNode(CATP62) ;
            		adaptor.AddChild(root_0, CATP62_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "catSP"

    public class jurycronoother_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "jurycronoother"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:203:1: jurycronoother : jury crono other ;
    public SwimmingCompetitionGrammarParser.jurycronoother_return jurycronoother() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.jurycronoother_return retval = new SwimmingCompetitionGrammarParser.jurycronoother_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        SwimmingCompetitionGrammarParser.jury_return jury63 = default(SwimmingCompetitionGrammarParser.jury_return);

        SwimmingCompetitionGrammarParser.crono_return crono64 = default(SwimmingCompetitionGrammarParser.crono_return);

        SwimmingCompetitionGrammarParser.other_return other65 = default(SwimmingCompetitionGrammarParser.other_return);



        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:204:2: ( jury crono other )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:205:2: jury crono other
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_jury_in_jurycronoother1540);
            	jury63 = jury();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, jury63.Tree);
            	PushFollow(FOLLOW_crono_in_jurycronoother1542);
            	crono64 = crono();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, crono64.Tree);
            	PushFollow(FOLLOW_other_in_jurycronoother1544);
            	other65 = other();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, other65.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "JURY { ... }");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "jurycronoother"

    public class jury_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "jury"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:207:1: jury : JURY A_GR referee ( coadjuctor )* depjudge ( falsestartempl )* compempl C_GR -> ^( JURY referee ( coadjuctor )* depjudge ( falsestartempl )* compempl ) ;
    public SwimmingCompetitionGrammarParser.jury_return jury() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.jury_return retval = new SwimmingCompetitionGrammarParser.jury_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken JURY66 = null;
        IToken A_GR67 = null;
        IToken C_GR73 = null;
        SwimmingCompetitionGrammarParser.referee_return referee68 = default(SwimmingCompetitionGrammarParser.referee_return);

        SwimmingCompetitionGrammarParser.coadjuctor_return coadjuctor69 = default(SwimmingCompetitionGrammarParser.coadjuctor_return);

        SwimmingCompetitionGrammarParser.depjudge_return depjudge70 = default(SwimmingCompetitionGrammarParser.depjudge_return);

        SwimmingCompetitionGrammarParser.falsestartempl_return falsestartempl71 = default(SwimmingCompetitionGrammarParser.falsestartempl_return);

        SwimmingCompetitionGrammarParser.compempl_return compempl72 = default(SwimmingCompetitionGrammarParser.compempl_return);


        CommonTree JURY66_tree=null;
        CommonTree A_GR67_tree=null;
        CommonTree C_GR73_tree=null;
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleTokenStream stream_JURY = new RewriteRuleTokenStream(adaptor,"token JURY");
        RewriteRuleSubtreeStream stream_depjudge = new RewriteRuleSubtreeStream(adaptor,"rule depjudge");
        RewriteRuleSubtreeStream stream_referee = new RewriteRuleSubtreeStream(adaptor,"rule referee");
        RewriteRuleSubtreeStream stream_compempl = new RewriteRuleSubtreeStream(adaptor,"rule compempl");
        RewriteRuleSubtreeStream stream_coadjuctor = new RewriteRuleSubtreeStream(adaptor,"rule coadjuctor");
        RewriteRuleSubtreeStream stream_falsestartempl = new RewriteRuleSubtreeStream(adaptor,"rule falsestartempl");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:208:2: ( JURY A_GR referee ( coadjuctor )* depjudge ( falsestartempl )* compempl C_GR -> ^( JURY referee ( coadjuctor )* depjudge ( falsestartempl )* compempl ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:209:2: JURY A_GR referee ( coadjuctor )* depjudge ( falsestartempl )* compempl C_GR
            {
            	JURY66=(IToken)Match(input,JURY,FOLLOW_JURY_in_jury1556);  
            	stream_JURY.Add(JURY66);

            	A_GR67=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_jury1559);  
            	stream_A_GR.Add(A_GR67);

            	PushFollow(FOLLOW_referee_in_jury1563);
            	referee68 = referee();
            	state.followingStackPointer--;

            	stream_referee.Add(referee68.Tree);
            	// C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:212:2: ( coadjuctor )*
            	do 
            	{
            	    int alt2 = 2;
            	    int LA2_0 = input.LA(1);

            	    if ( (LA2_0 == COADJUTOR) )
            	    {
            	        alt2 = 1;
            	    }


            	    switch (alt2) 
            		{
            			case 1 :
            			    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:212:3: coadjuctor
            			    {
            			    	PushFollow(FOLLOW_coadjuctor_in_jury1567);
            			    	coadjuctor69 = coadjuctor();
            			    	state.followingStackPointer--;

            			    	stream_coadjuctor.Add(coadjuctor69.Tree);

            			    }
            			    break;

            			default:
            			    goto loop2;
            	    }
            	} while (true);

            	loop2:
            		;	// Stops C# compiler whining that label 'loop2' has no statements

            	PushFollow(FOLLOW_depjudge_in_jury1572);
            	depjudge70 = depjudge();
            	state.followingStackPointer--;

            	stream_depjudge.Add(depjudge70.Tree);
            	// C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:214:2: ( falsestartempl )*
            	do 
            	{
            	    int alt3 = 2;
            	    int LA3_0 = input.LA(1);

            	    if ( (LA3_0 == FALSESTARTEMPL) )
            	    {
            	        alt3 = 1;
            	    }


            	    switch (alt3) 
            		{
            			case 1 :
            			    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:214:3: falsestartempl
            			    {
            			    	PushFollow(FOLLOW_falsestartempl_in_jury1576);
            			    	falsestartempl71 = falsestartempl();
            			    	state.followingStackPointer--;

            			    	stream_falsestartempl.Add(falsestartempl71.Tree);

            			    }
            			    break;

            			default:
            			    goto loop3;
            	    }
            	} while (true);

            	loop3:
            		;	// Stops C# compiler whining that label 'loop3' has no statements

            	PushFollow(FOLLOW_compempl_in_jury1581);
            	compempl72 = compempl();
            	state.followingStackPointer--;

            	stream_compempl.Add(compempl72.Tree);
            	C_GR73=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_jury1584);  
            	stream_C_GR.Add(C_GR73);



            	// AST REWRITE
            	// elements:          depjudge, coadjuctor, compempl, falsestartempl, referee, JURY
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 217:2: -> ^( JURY referee ( coadjuctor )* depjudge ( falsestartempl )* compempl )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:217:5: ^( JURY referee ( coadjuctor )* depjudge ( falsestartempl )* compempl )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.JuryNode(stream_JURY.NextToken()), root_1);

            	    adaptor.AddChild(root_1, stream_referee.NextTree());
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:220:2: ( coadjuctor )*
            	    while ( stream_coadjuctor.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_coadjuctor.NextTree());

            	    }
            	    stream_coadjuctor.Reset();
            	    adaptor.AddChild(root_1, stream_depjudge.NextTree());
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:222:2: ( falsestartempl )*
            	    while ( stream_falsestartempl.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_falsestartempl.NextTree());

            	    }
            	    stream_falsestartempl.Reset();
            	    adaptor.AddChild(root_1, stream_compempl.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "JURY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "jury"

    public class referee_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "referee"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:227:1: referee : REFEREE ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.referee_return referee() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.referee_return retval = new SwimmingCompetitionGrammarParser.referee_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken REFEREE74 = null;
        IToken char_literal75 = null;
        IToken STRING76 = null;

        CommonTree REFEREE74_tree=null;
        CommonTree char_literal75_tree=null;
        CommonTree STRING76_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_REFEREE = new RewriteRuleTokenStream(adaptor,"token REFEREE");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:227:9: ( REFEREE ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:227:11: REFEREE ':' STRING
            {
            	REFEREE74=(IToken)Match(input,REFEREE,FOLLOW_REFEREE_in_referee1636);  
            	stream_REFEREE.Add(REFEREE74);

            	char_literal75=(IToken)Match(input,97,FOLLOW_97_in_referee1638);  
            	stream_97.Add(char_literal75);

            	STRING76=(IToken)Match(input,STRING,FOLLOW_STRING_in_referee1640);  
            	stream_STRING.Add(STRING76);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 227:30: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:227:33: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.RefereeNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "REFEREE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "referee"

    public class coadjuctor_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "coadjuctor"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:228:1: coadjuctor : COADJUTOR ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.coadjuctor_return coadjuctor() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.coadjuctor_return retval = new SwimmingCompetitionGrammarParser.coadjuctor_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken COADJUTOR77 = null;
        IToken char_literal78 = null;
        IToken STRING79 = null;

        CommonTree COADJUTOR77_tree=null;
        CommonTree char_literal78_tree=null;
        CommonTree STRING79_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_COADJUTOR = new RewriteRuleTokenStream(adaptor,"token COADJUTOR");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:229:2: ( COADJUTOR ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:229:4: COADJUTOR ':' STRING
            {
            	COADJUTOR77=(IToken)Match(input,COADJUTOR,FOLLOW_COADJUTOR_in_coadjuctor1662);  
            	stream_COADJUTOR.Add(COADJUTOR77);

            	char_literal78=(IToken)Match(input,97,FOLLOW_97_in_coadjuctor1664);  
            	stream_97.Add(char_literal78);

            	STRING79=(IToken)Match(input,STRING,FOLLOW_STRING_in_coadjuctor1666);  
            	stream_STRING.Add(STRING79);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 229:25: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:229:28: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.CoadjuctorNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "COADJUCTOR");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "coadjuctor"

    public class depjudge_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "depjudge"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:230:1: depjudge : DEPJUDGE ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.depjudge_return depjudge() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.depjudge_return retval = new SwimmingCompetitionGrammarParser.depjudge_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken DEPJUDGE80 = null;
        IToken char_literal81 = null;
        IToken STRING82 = null;

        CommonTree DEPJUDGE80_tree=null;
        CommonTree char_literal81_tree=null;
        CommonTree STRING82_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_DEPJUDGE = new RewriteRuleTokenStream(adaptor,"token DEPJUDGE");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:231:2: ( DEPJUDGE ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:231:5: DEPJUDGE ':' STRING
            {
            	DEPJUDGE80=(IToken)Match(input,DEPJUDGE,FOLLOW_DEPJUDGE_in_depjudge1689);  
            	stream_DEPJUDGE.Add(DEPJUDGE80);

            	char_literal81=(IToken)Match(input,97,FOLLOW_97_in_depjudge1692);  
            	stream_97.Add(char_literal81);

            	STRING82=(IToken)Match(input,STRING,FOLLOW_STRING_in_depjudge1694);  
            	stream_STRING.Add(STRING82);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 231:26: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:231:29: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.DepJudgeNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "DEPJUDGE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "depjudge"

    public class falsestartempl_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "falsestartempl"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:232:1: falsestartempl : FALSESTARTEMPL ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.falsestartempl_return falsestartempl() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.falsestartempl_return retval = new SwimmingCompetitionGrammarParser.falsestartempl_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken FALSESTARTEMPL83 = null;
        IToken char_literal84 = null;
        IToken STRING85 = null;

        CommonTree FALSESTARTEMPL83_tree=null;
        CommonTree char_literal84_tree=null;
        CommonTree STRING85_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_FALSESTARTEMPL = new RewriteRuleTokenStream(adaptor,"token FALSESTARTEMPL");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:233:2: ( FALSESTARTEMPL ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:233:4: FALSESTARTEMPL ':' STRING
            {
            	FALSESTARTEMPL83=(IToken)Match(input,FALSESTARTEMPL,FOLLOW_FALSESTARTEMPL_in_falsestartempl1716);  
            	stream_FALSESTARTEMPL.Add(FALSESTARTEMPL83);

            	char_literal84=(IToken)Match(input,97,FOLLOW_97_in_falsestartempl1718);  
            	stream_97.Add(char_literal84);

            	STRING85=(IToken)Match(input,STRING,FOLLOW_STRING_in_falsestartempl1720);  
            	stream_STRING.Add(STRING85);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 233:30: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:233:33: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.FalseStartEmployeeNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "FALSESTARTEMPL");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "falsestartempl"

    public class compempl_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "compempl"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:234:1: compempl : COMPEMPL ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.compempl_return compempl() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.compempl_return retval = new SwimmingCompetitionGrammarParser.compempl_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken COMPEMPL86 = null;
        IToken char_literal87 = null;
        IToken STRING88 = null;

        CommonTree COMPEMPL86_tree=null;
        CommonTree char_literal87_tree=null;
        CommonTree STRING88_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_COMPEMPL = new RewriteRuleTokenStream(adaptor,"token COMPEMPL");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:235:2: ( COMPEMPL ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:235:4: COMPEMPL ':' STRING
            {
            	COMPEMPL86=(IToken)Match(input,COMPEMPL,FOLLOW_COMPEMPL_in_compempl1742);  
            	stream_COMPEMPL.Add(COMPEMPL86);

            	char_literal87=(IToken)Match(input,97,FOLLOW_97_in_compempl1744);  
            	stream_97.Add(char_literal87);

            	STRING88=(IToken)Match(input,STRING,FOLLOW_STRING_in_compempl1746);  
            	stream_STRING.Add(STRING88);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 235:24: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:235:27: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.CompEmployeeNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "COMPEMPL");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "compempl"

    public class crono_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "crono"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:236:1: crono : TIMING A_GR cronotype cronoserv cronosoc C_GR -> ^( TIMING cronotype cronoserv cronosoc ) ;
    public SwimmingCompetitionGrammarParser.crono_return crono() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.crono_return retval = new SwimmingCompetitionGrammarParser.crono_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TIMING89 = null;
        IToken A_GR90 = null;
        IToken C_GR94 = null;
        SwimmingCompetitionGrammarParser.cronotype_return cronotype91 = default(SwimmingCompetitionGrammarParser.cronotype_return);

        SwimmingCompetitionGrammarParser.cronoserv_return cronoserv92 = default(SwimmingCompetitionGrammarParser.cronoserv_return);

        SwimmingCompetitionGrammarParser.cronosoc_return cronosoc93 = default(SwimmingCompetitionGrammarParser.cronosoc_return);


        CommonTree TIMING89_tree=null;
        CommonTree A_GR90_tree=null;
        CommonTree C_GR94_tree=null;
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleTokenStream stream_TIMING = new RewriteRuleTokenStream(adaptor,"token TIMING");
        RewriteRuleSubtreeStream stream_cronotype = new RewriteRuleSubtreeStream(adaptor,"rule cronotype");
        RewriteRuleSubtreeStream stream_cronosoc = new RewriteRuleSubtreeStream(adaptor,"rule cronosoc");
        RewriteRuleSubtreeStream stream_cronoserv = new RewriteRuleSubtreeStream(adaptor,"rule cronoserv");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:237:2: ( TIMING A_GR cronotype cronoserv cronosoc C_GR -> ^( TIMING cronotype cronoserv cronosoc ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:238:2: TIMING A_GR cronotype cronoserv cronosoc C_GR
            {
            	TIMING89=(IToken)Match(input,TIMING,FOLLOW_TIMING_in_crono1770);  
            	stream_TIMING.Add(TIMING89);

            	A_GR90=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_crono1773);  
            	stream_A_GR.Add(A_GR90);

            	PushFollow(FOLLOW_cronotype_in_crono1777);
            	cronotype91 = cronotype();
            	state.followingStackPointer--;

            	stream_cronotype.Add(cronotype91.Tree);
            	PushFollow(FOLLOW_cronoserv_in_crono1780);
            	cronoserv92 = cronoserv();
            	state.followingStackPointer--;

            	stream_cronoserv.Add(cronoserv92.Tree);
            	PushFollow(FOLLOW_cronosoc_in_crono1783);
            	cronosoc93 = cronosoc();
            	state.followingStackPointer--;

            	stream_cronosoc.Add(cronosoc93.Tree);
            	C_GR94=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_crono1786);  
            	stream_C_GR.Add(C_GR94);



            	// AST REWRITE
            	// elements:          TIMING, cronoserv, cronotype, cronosoc
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 244:2: -> ^( TIMING cronotype cronoserv cronosoc )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:244:5: ^( TIMING cronotype cronoserv cronosoc )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.TimingNode(stream_TIMING.NextToken()), root_1);

            	    adaptor.AddChild(root_1, stream_cronotype.NextTree());
            	    adaptor.AddChild(root_1, stream_cronoserv.NextTree());
            	    adaptor.AddChild(root_1, stream_cronosoc.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CRONO");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "crono"

    public class cronotype_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "cronotype"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:250:1: cronotype : CRONOTYPE ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.cronotype_return cronotype() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.cronotype_return retval = new SwimmingCompetitionGrammarParser.cronotype_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken CRONOTYPE95 = null;
        IToken char_literal96 = null;
        IToken STRING97 = null;

        CommonTree CRONOTYPE95_tree=null;
        CommonTree char_literal96_tree=null;
        CommonTree STRING97_tree=null;
        RewriteRuleTokenStream stream_CRONOTYPE = new RewriteRuleTokenStream(adaptor,"token CRONOTYPE");
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:251:2: ( CRONOTYPE ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:251:4: CRONOTYPE ':' STRING
            {
            	CRONOTYPE95=(IToken)Match(input,CRONOTYPE,FOLLOW_CRONOTYPE_in_cronotype1824);  
            	stream_CRONOTYPE.Add(CRONOTYPE95);

            	char_literal96=(IToken)Match(input,97,FOLLOW_97_in_cronotype1826);  
            	stream_97.Add(char_literal96);

            	STRING97=(IToken)Match(input,STRING,FOLLOW_STRING_in_cronotype1828);  
            	stream_STRING.Add(STRING97);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 251:25: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:251:28: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.CronoTypeNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CRONOTYPE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "cronotype"

    public class cronoserv_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "cronoserv"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:252:1: cronoserv : CRONOSERV ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.cronoserv_return cronoserv() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.cronoserv_return retval = new SwimmingCompetitionGrammarParser.cronoserv_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken CRONOSERV98 = null;
        IToken char_literal99 = null;
        IToken STRING100 = null;

        CommonTree CRONOSERV98_tree=null;
        CommonTree char_literal99_tree=null;
        CommonTree STRING100_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_CRONOSERV = new RewriteRuleTokenStream(adaptor,"token CRONOSERV");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:253:2: ( CRONOSERV ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:253:4: CRONOSERV ':' STRING
            {
            	CRONOSERV98=(IToken)Match(input,CRONOSERV,FOLLOW_CRONOSERV_in_cronoserv1849);  
            	stream_CRONOSERV.Add(CRONOSERV98);

            	char_literal99=(IToken)Match(input,97,FOLLOW_97_in_cronoserv1851);  
            	stream_97.Add(char_literal99);

            	STRING100=(IToken)Match(input,STRING,FOLLOW_STRING_in_cronoserv1853);  
            	stream_STRING.Add(STRING100);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 253:25: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:253:28: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.CronoServiceNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CRONOSERV");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "cronoserv"

    public class cronosoc_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "cronosoc"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:254:1: cronosoc : CRONOSOC ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.cronosoc_return cronosoc() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.cronosoc_return retval = new SwimmingCompetitionGrammarParser.cronosoc_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken CRONOSOC101 = null;
        IToken char_literal102 = null;
        IToken STRING103 = null;

        CommonTree CRONOSOC101_tree=null;
        CommonTree char_literal102_tree=null;
        CommonTree STRING103_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_CRONOSOC = new RewriteRuleTokenStream(adaptor,"token CRONOSOC");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:254:9: ( CRONOSOC ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:254:11: CRONOSOC ':' STRING
            {
            	CRONOSOC101=(IToken)Match(input,CRONOSOC,FOLLOW_CRONOSOC_in_cronosoc1872);  
            	stream_CRONOSOC.Add(CRONOSOC101);

            	char_literal102=(IToken)Match(input,97,FOLLOW_97_in_cronosoc1874);  
            	stream_97.Add(char_literal102);

            	STRING103=(IToken)Match(input,STRING,FOLLOW_STRING_in_cronosoc1876);  
            	stream_STRING.Add(STRING103);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 254:31: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:254:34: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.CronoSocietyNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CRONOSOC");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "cronosoc"

    public class other_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "other"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:256:1: other : OTHER A_GR speak doct manag C_GR -> ^( OTHER speak doct manag ) ;
    public SwimmingCompetitionGrammarParser.other_return other() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.other_return retval = new SwimmingCompetitionGrammarParser.other_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken OTHER104 = null;
        IToken A_GR105 = null;
        IToken C_GR109 = null;
        SwimmingCompetitionGrammarParser.speak_return speak106 = default(SwimmingCompetitionGrammarParser.speak_return);

        SwimmingCompetitionGrammarParser.doct_return doct107 = default(SwimmingCompetitionGrammarParser.doct_return);

        SwimmingCompetitionGrammarParser.manag_return manag108 = default(SwimmingCompetitionGrammarParser.manag_return);


        CommonTree OTHER104_tree=null;
        CommonTree A_GR105_tree=null;
        CommonTree C_GR109_tree=null;
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_OTHER = new RewriteRuleTokenStream(adaptor,"token OTHER");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleSubtreeStream stream_doct = new RewriteRuleSubtreeStream(adaptor,"rule doct");
        RewriteRuleSubtreeStream stream_manag = new RewriteRuleSubtreeStream(adaptor,"rule manag");
        RewriteRuleSubtreeStream stream_speak = new RewriteRuleSubtreeStream(adaptor,"rule speak");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:256:8: ( OTHER A_GR speak doct manag C_GR -> ^( OTHER speak doct manag ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:257:2: OTHER A_GR speak doct manag C_GR
            {
            	OTHER104=(IToken)Match(input,OTHER,FOLLOW_OTHER_in_other1900);  
            	stream_OTHER.Add(OTHER104);

            	A_GR105=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_other1903);  
            	stream_A_GR.Add(A_GR105);

            	PushFollow(FOLLOW_speak_in_other1907);
            	speak106 = speak();
            	state.followingStackPointer--;

            	stream_speak.Add(speak106.Tree);
            	PushFollow(FOLLOW_doct_in_other1910);
            	doct107 = doct();
            	state.followingStackPointer--;

            	stream_doct.Add(doct107.Tree);
            	PushFollow(FOLLOW_manag_in_other1913);
            	manag108 = manag();
            	state.followingStackPointer--;

            	stream_manag.Add(manag108.Tree);
            	C_GR109=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_other1916);  
            	stream_C_GR.Add(C_GR109);



            	// AST REWRITE
            	// elements:          manag, doct, speak, OTHER
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 263:2: -> ^( OTHER speak doct manag )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:263:5: ^( OTHER speak doct manag )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.OtherNode(stream_OTHER.NextToken()), root_1);

            	    adaptor.AddChild(root_1, stream_speak.NextTree());
            	    adaptor.AddChild(root_1, stream_doct.NextTree());
            	    adaptor.AddChild(root_1, stream_manag.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "OTHER");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "other"

    public class speak_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "speak"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:269:1: speak : SPEAK ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.speak_return speak() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.speak_return retval = new SwimmingCompetitionGrammarParser.speak_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken SPEAK110 = null;
        IToken char_literal111 = null;
        IToken STRING112 = null;

        CommonTree SPEAK110_tree=null;
        CommonTree char_literal111_tree=null;
        CommonTree STRING112_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_SPEAK = new RewriteRuleTokenStream(adaptor,"token SPEAK");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:269:7: ( SPEAK ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:269:9: SPEAK ':' STRING
            {
            	SPEAK110=(IToken)Match(input,SPEAK,FOLLOW_SPEAK_in_speak1952);  
            	stream_SPEAK.Add(SPEAK110);

            	char_literal111=(IToken)Match(input,97,FOLLOW_97_in_speak1954);  
            	stream_97.Add(char_literal111);

            	STRING112=(IToken)Match(input,STRING,FOLLOW_STRING_in_speak1957);  
            	stream_STRING.Add(STRING112);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 269:27: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:269:30: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.SpeakerNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "SPEAK");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "speak"

    public class doct_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "doct"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:270:1: doct : DOCT ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.doct_return doct() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.doct_return retval = new SwimmingCompetitionGrammarParser.doct_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken DOCT113 = null;
        IToken char_literal114 = null;
        IToken STRING115 = null;

        CommonTree DOCT113_tree=null;
        CommonTree char_literal114_tree=null;
        CommonTree STRING115_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_DOCT = new RewriteRuleTokenStream(adaptor,"token DOCT");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:270:6: ( DOCT ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:270:8: DOCT ':' STRING
            {
            	DOCT113=(IToken)Match(input,DOCT,FOLLOW_DOCT_in_doct1977);  
            	stream_DOCT.Add(DOCT113);

            	char_literal114=(IToken)Match(input,97,FOLLOW_97_in_doct1979);  
            	stream_97.Add(char_literal114);

            	STRING115=(IToken)Match(input,STRING,FOLLOW_STRING_in_doct1982);  
            	stream_STRING.Add(STRING115);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 270:25: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:270:28: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.DoctorNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "DOCT");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "doct"

    public class manag_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "manag"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:271:1: manag : MANAG ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.manag_return manag() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.manag_return retval = new SwimmingCompetitionGrammarParser.manag_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken MANAG116 = null;
        IToken char_literal117 = null;
        IToken STRING118 = null;

        CommonTree MANAG116_tree=null;
        CommonTree char_literal117_tree=null;
        CommonTree STRING118_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_MANAG = new RewriteRuleTokenStream(adaptor,"token MANAG");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:271:7: ( MANAG ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:271:9: MANAG ':' STRING
            {
            	MANAG116=(IToken)Match(input,MANAG,FOLLOW_MANAG_in_manag2002);  
            	stream_MANAG.Add(MANAG116);

            	char_literal117=(IToken)Match(input,97,FOLLOW_97_in_manag2004);  
            	stream_97.Add(char_literal117);

            	STRING118=(IToken)Match(input,STRING,FOLLOW_STRING_in_manag2006);  
            	stream_STRING.Add(STRING118);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 271:26: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:271:29: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.ManagerNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "MANAG");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "manag"

    public class programcomp_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "programcomp"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:273:1: programcomp : PROG A_GR ( programSingleDay )+ C_GR -> ^( PROG ( programSingleDay )+ ) ;
    public SwimmingCompetitionGrammarParser.programcomp_return programcomp() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.programcomp_return retval = new SwimmingCompetitionGrammarParser.programcomp_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken PROG119 = null;
        IToken A_GR120 = null;
        IToken C_GR122 = null;
        SwimmingCompetitionGrammarParser.programSingleDay_return programSingleDay121 = default(SwimmingCompetitionGrammarParser.programSingleDay_return);


        CommonTree PROG119_tree=null;
        CommonTree A_GR120_tree=null;
        CommonTree C_GR122_tree=null;
        RewriteRuleTokenStream stream_PROG = new RewriteRuleTokenStream(adaptor,"token PROG");
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleSubtreeStream stream_programSingleDay = new RewriteRuleSubtreeStream(adaptor,"rule programSingleDay");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:274:2: ( PROG A_GR ( programSingleDay )+ C_GR -> ^( PROG ( programSingleDay )+ ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:275:2: PROG A_GR ( programSingleDay )+ C_GR
            {
            	PROG119=(IToken)Match(input,PROG,FOLLOW_PROG_in_programcomp2030);  
            	stream_PROG.Add(PROG119);

            	A_GR120=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_programcomp2033);  
            	stream_A_GR.Add(A_GR120);

            	// C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:277:2: ( programSingleDay )+
            	int cnt4 = 0;
            	do 
            	{
            	    int alt4 = 2;
            	    int LA4_0 = input.LA(1);

            	    if ( (LA4_0 == DATECOMP) )
            	    {
            	        alt4 = 1;
            	    }


            	    switch (alt4) 
            		{
            			case 1 :
            			    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:277:3: programSingleDay
            			    {
            			    	PushFollow(FOLLOW_programSingleDay_in_programcomp2037);
            			    	programSingleDay121 = programSingleDay();
            			    	state.followingStackPointer--;

            			    	stream_programSingleDay.Add(programSingleDay121.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt4 >= 1 ) goto loop4;
            		            EarlyExitException eee4 =
            		                new EarlyExitException(4, input);
            		            throw eee4;
            	    }
            	    cnt4++;
            	} while (true);

            	loop4:
            		;	// Stops C# compiler whining that label 'loop4' has no statements

            	C_GR122=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_programcomp2042);  
            	stream_C_GR.Add(C_GR122);



            	// AST REWRITE
            	// elements:          PROG, programSingleDay
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 279:2: -> ^( PROG ( programSingleDay )+ )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:279:5: ^( PROG ( programSingleDay )+ )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.ProgNode(stream_PROG.NextToken()), root_1);

            	    if ( !(stream_programSingleDay.HasNext()) ) {
            	        throw new RewriteEarlyExitException();
            	    }
            	    while ( stream_programSingleDay.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_programSingleDay.NextTree());

            	    }
            	    stream_programSingleDay.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "PROGRAMCOMP");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "programcomp"

    public class programSingleDay_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "programSingleDay"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:283:1: programSingleDay : DATECOMP ':' DATE A_GR ( competition )+ C_GR -> ^( DATE ( competition )+ ) ;
    public SwimmingCompetitionGrammarParser.programSingleDay_return programSingleDay() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.programSingleDay_return retval = new SwimmingCompetitionGrammarParser.programSingleDay_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken DATECOMP123 = null;
        IToken char_literal124 = null;
        IToken DATE125 = null;
        IToken A_GR126 = null;
        IToken C_GR128 = null;
        SwimmingCompetitionGrammarParser.competition_return competition127 = default(SwimmingCompetitionGrammarParser.competition_return);


        CommonTree DATECOMP123_tree=null;
        CommonTree char_literal124_tree=null;
        CommonTree DATE125_tree=null;
        CommonTree A_GR126_tree=null;
        CommonTree C_GR128_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_DATECOMP = new RewriteRuleTokenStream(adaptor,"token DATECOMP");
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleTokenStream stream_DATE = new RewriteRuleTokenStream(adaptor,"token DATE");
        RewriteRuleSubtreeStream stream_competition = new RewriteRuleSubtreeStream(adaptor,"rule competition");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:284:2: ( DATECOMP ':' DATE A_GR ( competition )+ C_GR -> ^( DATE ( competition )+ ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:285:2: DATECOMP ':' DATE A_GR ( competition )+ C_GR
            {
            	DATECOMP123=(IToken)Match(input,DATECOMP,FOLLOW_DATECOMP_in_programSingleDay2079);  
            	stream_DATECOMP.Add(DATECOMP123);

            	char_literal124=(IToken)Match(input,97,FOLLOW_97_in_programSingleDay2081);  
            	stream_97.Add(char_literal124);

            	DATE125=(IToken)Match(input,DATE,FOLLOW_DATE_in_programSingleDay2083);  
            	stream_DATE.Add(DATE125);

            	A_GR126=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_programSingleDay2086);  
            	stream_A_GR.Add(A_GR126);

            	// C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:287:3: ( competition )+
            	int cnt5 = 0;
            	do 
            	{
            	    int alt5 = 2;
            	    int LA5_0 = input.LA(1);

            	    if ( (LA5_0 == A_Q) )
            	    {
            	        alt5 = 1;
            	    }


            	    switch (alt5) 
            		{
            			case 1 :
            			    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:287:4: competition
            			    {
            			    	PushFollow(FOLLOW_competition_in_programSingleDay2092);
            			    	competition127 = competition();
            			    	state.followingStackPointer--;

            			    	stream_competition.Add(competition127.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt5 >= 1 ) goto loop5;
            		            EarlyExitException eee5 =
            		                new EarlyExitException(5, input);
            		            throw eee5;
            	    }
            	    cnt5++;
            	} while (true);

            	loop5:
            		;	// Stops C# compiler whining that label 'loop5' has no statements

            	C_GR128=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_programSingleDay2097);  
            	stream_C_GR.Add(C_GR128);



            	// AST REWRITE
            	// elements:          DATE, competition
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 289:2: -> ^( DATE ( competition )+ )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:289:5: ^( DATE ( competition )+ )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.DateProgCompNode(stream_DATE.NextToken()), root_1);

            	    if ( !(stream_competition.HasNext()) ) {
            	        throw new RewriteEarlyExitException();
            	    }
            	    while ( stream_competition.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_competition.NextTree());

            	    }
            	    stream_competition.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "PROGRAM SINGLE DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "programSingleDay"

    public class competition_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "competition"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:292:1: competition : A_Q hourcomp categorycomp speccomp turncomp C_Q -> ^( speccomp hourcomp categorycomp turncomp ) ;
    public SwimmingCompetitionGrammarParser.competition_return competition() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.competition_return retval = new SwimmingCompetitionGrammarParser.competition_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken A_Q129 = null;
        IToken C_Q134 = null;
        SwimmingCompetitionGrammarParser.hourcomp_return hourcomp130 = default(SwimmingCompetitionGrammarParser.hourcomp_return);

        SwimmingCompetitionGrammarParser.categorycomp_return categorycomp131 = default(SwimmingCompetitionGrammarParser.categorycomp_return);

        SwimmingCompetitionGrammarParser.speccomp_return speccomp132 = default(SwimmingCompetitionGrammarParser.speccomp_return);

        SwimmingCompetitionGrammarParser.turncomp_return turncomp133 = default(SwimmingCompetitionGrammarParser.turncomp_return);


        CommonTree A_Q129_tree=null;
        CommonTree C_Q134_tree=null;
        RewriteRuleTokenStream stream_A_Q = new RewriteRuleTokenStream(adaptor,"token A_Q");
        RewriteRuleTokenStream stream_C_Q = new RewriteRuleTokenStream(adaptor,"token C_Q");
        RewriteRuleSubtreeStream stream_categorycomp = new RewriteRuleSubtreeStream(adaptor,"rule categorycomp");
        RewriteRuleSubtreeStream stream_speccomp = new RewriteRuleSubtreeStream(adaptor,"rule speccomp");
        RewriteRuleSubtreeStream stream_hourcomp = new RewriteRuleSubtreeStream(adaptor,"rule hourcomp");
        RewriteRuleSubtreeStream stream_turncomp = new RewriteRuleSubtreeStream(adaptor,"rule turncomp");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:293:2: ( A_Q hourcomp categorycomp speccomp turncomp C_Q -> ^( speccomp hourcomp categorycomp turncomp ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:294:2: A_Q hourcomp categorycomp speccomp turncomp C_Q
            {
            	A_Q129=(IToken)Match(input,A_Q,FOLLOW_A_Q_in_competition2130);  
            	stream_A_Q.Add(A_Q129);

            	PushFollow(FOLLOW_hourcomp_in_competition2133);
            	hourcomp130 = hourcomp();
            	state.followingStackPointer--;

            	stream_hourcomp.Add(hourcomp130.Tree);
            	PushFollow(FOLLOW_categorycomp_in_competition2136);
            	categorycomp131 = categorycomp();
            	state.followingStackPointer--;

            	stream_categorycomp.Add(categorycomp131.Tree);
            	PushFollow(FOLLOW_speccomp_in_competition2139);
            	speccomp132 = speccomp();
            	state.followingStackPointer--;

            	stream_speccomp.Add(speccomp132.Tree);
            	PushFollow(FOLLOW_turncomp_in_competition2142);
            	turncomp133 = turncomp();
            	state.followingStackPointer--;

            	stream_turncomp.Add(turncomp133.Tree);
            	C_Q134=(IToken)Match(input,C_Q,FOLLOW_C_Q_in_competition2145);  
            	stream_C_Q.Add(C_Q134);



            	// AST REWRITE
            	// elements:          turncomp, hourcomp, speccomp, categorycomp
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 300:2: -> ^( speccomp hourcomp categorycomp turncomp )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:300:5: ^( speccomp hourcomp categorycomp turncomp )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_speccomp.NextNode(), root_1);

            	    adaptor.AddChild(root_1, stream_hourcomp.NextTree());
            	    adaptor.AddChild(root_1, stream_categorycomp.NextTree());
            	    adaptor.AddChild(root_1, stream_turncomp.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "competition"

    public class hourcomp_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "hourcomp"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:303:1: hourcomp : HOURCOMP ':' HOUR -> ^( HOUR ) ;
    public SwimmingCompetitionGrammarParser.hourcomp_return hourcomp() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.hourcomp_return retval = new SwimmingCompetitionGrammarParser.hourcomp_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken HOURCOMP135 = null;
        IToken char_literal136 = null;
        IToken HOUR137 = null;

        CommonTree HOURCOMP135_tree=null;
        CommonTree char_literal136_tree=null;
        CommonTree HOUR137_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_HOUR = new RewriteRuleTokenStream(adaptor,"token HOUR");
        RewriteRuleTokenStream stream_HOURCOMP = new RewriteRuleTokenStream(adaptor,"token HOURCOMP");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:303:9: ( HOURCOMP ':' HOUR -> ^( HOUR ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:303:11: HOURCOMP ':' HOUR
            {
            	HOURCOMP135=(IToken)Match(input,HOURCOMP,FOLLOW_HOURCOMP_in_hourcomp2168);  
            	stream_HOURCOMP.Add(HOURCOMP135);

            	char_literal136=(IToken)Match(input,97,FOLLOW_97_in_hourcomp2170);  
            	stream_97.Add(char_literal136);

            	HOUR137=(IToken)Match(input,HOUR,FOLLOW_HOUR_in_hourcomp2172);  
            	stream_HOUR.Add(HOUR137);



            	// AST REWRITE
            	// elements:          HOUR
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 303:29: -> ^( HOUR )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:303:32: ^( HOUR )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.HourNode(stream_HOUR.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "HOURCOMP");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "hourcomp"

    public class categorycomp_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "categorycomp"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:304:1: categorycomp : CATEGORYCOMP ':' categorySingleComp ;
    public SwimmingCompetitionGrammarParser.categorycomp_return categorycomp() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.categorycomp_return retval = new SwimmingCompetitionGrammarParser.categorycomp_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken CATEGORYCOMP138 = null;
        IToken char_literal139 = null;
        SwimmingCompetitionGrammarParser.categorySingleComp_return categorySingleComp140 = default(SwimmingCompetitionGrammarParser.categorySingleComp_return);


        CommonTree CATEGORYCOMP138_tree=null;
        CommonTree char_literal139_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:305:2: ( CATEGORYCOMP ':' categorySingleComp )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:305:4: CATEGORYCOMP ':' categorySingleComp
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	CATEGORYCOMP138=(IToken)Match(input,CATEGORYCOMP,FOLLOW_CATEGORYCOMP_in_categorycomp2193); 
            	char_literal139=(IToken)Match(input,97,FOLLOW_97_in_categorycomp2196); 
            	PushFollow(FOLLOW_categorySingleComp_in_categorycomp2199);
            	categorySingleComp140 = categorySingleComp();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, categorySingleComp140.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORYCOMP");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "categorycomp"

    public class speccomp_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "speccomp"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:306:1: speccomp : SPECCOMP ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.speccomp_return speccomp() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.speccomp_return retval = new SwimmingCompetitionGrammarParser.speccomp_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken SPECCOMP141 = null;
        IToken char_literal142 = null;
        IToken STRING143 = null;

        CommonTree SPECCOMP141_tree=null;
        CommonTree char_literal142_tree=null;
        CommonTree STRING143_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_SPECCOMP = new RewriteRuleTokenStream(adaptor,"token SPECCOMP");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:306:9: ( SPECCOMP ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:306:11: SPECCOMP ':' STRING
            {
            	SPECCOMP141=(IToken)Match(input,SPECCOMP,FOLLOW_SPECCOMP_in_speccomp2205);  
            	stream_SPECCOMP.Add(SPECCOMP141);

            	char_literal142=(IToken)Match(input,97,FOLLOW_97_in_speccomp2207);  
            	stream_97.Add(char_literal142);

            	STRING143=(IToken)Match(input,STRING,FOLLOW_STRING_in_speccomp2209);  
            	stream_STRING.Add(STRING143);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 306:31: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:306:34: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.SpecCompNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "SPECCOMP");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "speccomp"

    public class turncomp_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "turncomp"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:307:1: turncomp : TURNCOMP ':' typeturncomp ;
    public SwimmingCompetitionGrammarParser.turncomp_return turncomp() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.turncomp_return retval = new SwimmingCompetitionGrammarParser.turncomp_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TURNCOMP144 = null;
        IToken char_literal145 = null;
        SwimmingCompetitionGrammarParser.typeturncomp_return typeturncomp146 = default(SwimmingCompetitionGrammarParser.typeturncomp_return);


        CommonTree TURNCOMP144_tree=null;
        CommonTree char_literal145_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:307:9: ( TURNCOMP ':' typeturncomp )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:307:11: TURNCOMP ':' typeturncomp
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TURNCOMP144=(IToken)Match(input,TURNCOMP,FOLLOW_TURNCOMP_in_turncomp2228); 
            	char_literal145=(IToken)Match(input,97,FOLLOW_97_in_turncomp2231); 
            	PushFollow(FOLLOW_typeturncomp_in_turncomp2234);
            	typeturncomp146 = typeturncomp();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, typeturncomp146.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "TURNCOMP");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "turncomp"

    public class categorySingleComp_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "categorySingleComp"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:309:1: categorySingleComp : ( typeesa | typeesb | typep1 | typep2 | typep3 | typep4 | typep5 | typep6 | typep7 | typer | typej | typec | types | typeabs | typeu25 | typem25 | typem30 | typem35 | typem40 | typem45 | typem50 | typem55 | typem60 | typem65 ) ;
    public SwimmingCompetitionGrammarParser.categorySingleComp_return categorySingleComp() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.categorySingleComp_return retval = new SwimmingCompetitionGrammarParser.categorySingleComp_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        SwimmingCompetitionGrammarParser.typeesa_return typeesa147 = default(SwimmingCompetitionGrammarParser.typeesa_return);

        SwimmingCompetitionGrammarParser.typeesb_return typeesb148 = default(SwimmingCompetitionGrammarParser.typeesb_return);

        SwimmingCompetitionGrammarParser.typep1_return typep1149 = default(SwimmingCompetitionGrammarParser.typep1_return);

        SwimmingCompetitionGrammarParser.typep2_return typep2150 = default(SwimmingCompetitionGrammarParser.typep2_return);

        SwimmingCompetitionGrammarParser.typep3_return typep3151 = default(SwimmingCompetitionGrammarParser.typep3_return);

        SwimmingCompetitionGrammarParser.typep4_return typep4152 = default(SwimmingCompetitionGrammarParser.typep4_return);

        SwimmingCompetitionGrammarParser.typep5_return typep5153 = default(SwimmingCompetitionGrammarParser.typep5_return);

        SwimmingCompetitionGrammarParser.typep6_return typep6154 = default(SwimmingCompetitionGrammarParser.typep6_return);

        SwimmingCompetitionGrammarParser.typep7_return typep7155 = default(SwimmingCompetitionGrammarParser.typep7_return);

        SwimmingCompetitionGrammarParser.typer_return typer156 = default(SwimmingCompetitionGrammarParser.typer_return);

        SwimmingCompetitionGrammarParser.typej_return typej157 = default(SwimmingCompetitionGrammarParser.typej_return);

        SwimmingCompetitionGrammarParser.typec_return typec158 = default(SwimmingCompetitionGrammarParser.typec_return);

        SwimmingCompetitionGrammarParser.types_return types159 = default(SwimmingCompetitionGrammarParser.types_return);

        SwimmingCompetitionGrammarParser.typeabs_return typeabs160 = default(SwimmingCompetitionGrammarParser.typeabs_return);

        SwimmingCompetitionGrammarParser.typeu25_return typeu25161 = default(SwimmingCompetitionGrammarParser.typeu25_return);

        SwimmingCompetitionGrammarParser.typem25_return typem25162 = default(SwimmingCompetitionGrammarParser.typem25_return);

        SwimmingCompetitionGrammarParser.typem30_return typem30163 = default(SwimmingCompetitionGrammarParser.typem30_return);

        SwimmingCompetitionGrammarParser.typem35_return typem35164 = default(SwimmingCompetitionGrammarParser.typem35_return);

        SwimmingCompetitionGrammarParser.typem40_return typem40165 = default(SwimmingCompetitionGrammarParser.typem40_return);

        SwimmingCompetitionGrammarParser.typem45_return typem45166 = default(SwimmingCompetitionGrammarParser.typem45_return);

        SwimmingCompetitionGrammarParser.typem50_return typem50167 = default(SwimmingCompetitionGrammarParser.typem50_return);

        SwimmingCompetitionGrammarParser.typem55_return typem55168 = default(SwimmingCompetitionGrammarParser.typem55_return);

        SwimmingCompetitionGrammarParser.typem60_return typem60169 = default(SwimmingCompetitionGrammarParser.typem60_return);

        SwimmingCompetitionGrammarParser.typem65_return typem65170 = default(SwimmingCompetitionGrammarParser.typem65_return);



        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:2: ( ( typeesa | typeesb | typep1 | typep2 | typep3 | typep4 | typep5 | typep6 | typep7 | typer | typej | typec | types | typeabs | typeu25 | typem25 | typem30 | typem35 | typem40 | typem45 | typem50 | typem55 | typem60 | typem65 ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:4: ( typeesa | typeesb | typep1 | typep2 | typep3 | typep4 | typep5 | typep6 | typep7 | typer | typej | typec | types | typeabs | typeu25 | typem25 | typem30 | typem35 | typem40 | typem45 | typem50 | typem55 | typem60 | typem65 )
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	// C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:4: ( typeesa | typeesb | typep1 | typep2 | typep3 | typep4 | typep5 | typep6 | typep7 | typer | typej | typec | types | typeabs | typeu25 | typem25 | typem30 | typem35 | typem40 | typem45 | typem50 | typem55 | typem60 | typem65 )
            	int alt6 = 24;
            	switch ( input.LA(1) ) 
            	{
            	case TYPEESA:
            		{
            	    alt6 = 1;
            	    }
            	    break;
            	case TYPEESB:
            		{
            	    alt6 = 2;
            	    }
            	    break;
            	case TYPEP1:
            		{
            	    alt6 = 3;
            	    }
            	    break;
            	case TYPEP2:
            		{
            	    alt6 = 4;
            	    }
            	    break;
            	case TYPEP3:
            		{
            	    alt6 = 5;
            	    }
            	    break;
            	case TYPEP4:
            		{
            	    alt6 = 6;
            	    }
            	    break;
            	case TYPEP5:
            		{
            	    alt6 = 7;
            	    }
            	    break;
            	case TYPEP6:
            		{
            	    alt6 = 8;
            	    }
            	    break;
            	case TYPEP7:
            		{
            	    alt6 = 9;
            	    }
            	    break;
            	case TYPER:
            		{
            	    alt6 = 10;
            	    }
            	    break;
            	case TYPEJ:
            		{
            	    alt6 = 11;
            	    }
            	    break;
            	case TYPEC:
            		{
            	    alt6 = 12;
            	    }
            	    break;
            	case TYPES:
            		{
            	    alt6 = 13;
            	    }
            	    break;
            	case TYPEABS:
            		{
            	    alt6 = 14;
            	    }
            	    break;
            	case TYPEU25:
            		{
            	    alt6 = 15;
            	    }
            	    break;
            	case TYPEM25:
            		{
            	    alt6 = 16;
            	    }
            	    break;
            	case TYPEM30:
            		{
            	    alt6 = 17;
            	    }
            	    break;
            	case TYPEM35:
            		{
            	    alt6 = 18;
            	    }
            	    break;
            	case TYPEM40:
            		{
            	    alt6 = 19;
            	    }
            	    break;
            	case TYPEM45:
            		{
            	    alt6 = 20;
            	    }
            	    break;
            	case TYPEM50:
            		{
            	    alt6 = 21;
            	    }
            	    break;
            	case TYPEM55:
            		{
            	    alt6 = 22;
            	    }
            	    break;
            	case TYPEM60:
            		{
            	    alt6 = 23;
            	    }
            	    break;
            	case TYPEM65:
            		{
            	    alt6 = 24;
            	    }
            	    break;
            		default:
            		    NoViableAltException nvae_d6s0 =
            		        new NoViableAltException("", 6, 0, input);

            		    throw nvae_d6s0;
            	}

            	switch (alt6) 
            	{
            	    case 1 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:6: typeesa
            	        {
            	        	PushFollow(FOLLOW_typeesa_in_categorySingleComp2246);
            	        	typeesa147 = typeesa();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typeesa147.Tree);

            	        }
            	        break;
            	    case 2 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:16: typeesb
            	        {
            	        	PushFollow(FOLLOW_typeesb_in_categorySingleComp2250);
            	        	typeesb148 = typeesb();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typeesb148.Tree);

            	        }
            	        break;
            	    case 3 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:25: typep1
            	        {
            	        	PushFollow(FOLLOW_typep1_in_categorySingleComp2253);
            	        	typep1149 = typep1();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typep1149.Tree);

            	        }
            	        break;
            	    case 4 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:34: typep2
            	        {
            	        	PushFollow(FOLLOW_typep2_in_categorySingleComp2257);
            	        	typep2150 = typep2();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typep2150.Tree);

            	        }
            	        break;
            	    case 5 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:42: typep3
            	        {
            	        	PushFollow(FOLLOW_typep3_in_categorySingleComp2260);
            	        	typep3151 = typep3();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typep3151.Tree);

            	        }
            	        break;
            	    case 6 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:50: typep4
            	        {
            	        	PushFollow(FOLLOW_typep4_in_categorySingleComp2263);
            	        	typep4152 = typep4();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typep4152.Tree);

            	        }
            	        break;
            	    case 7 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:58: typep5
            	        {
            	        	PushFollow(FOLLOW_typep5_in_categorySingleComp2266);
            	        	typep5153 = typep5();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typep5153.Tree);

            	        }
            	        break;
            	    case 8 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:66: typep6
            	        {
            	        	PushFollow(FOLLOW_typep6_in_categorySingleComp2269);
            	        	typep6154 = typep6();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typep6154.Tree);

            	        }
            	        break;
            	    case 9 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:74: typep7
            	        {
            	        	PushFollow(FOLLOW_typep7_in_categorySingleComp2272);
            	        	typep7155 = typep7();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typep7155.Tree);

            	        }
            	        break;
            	    case 10 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:82: typer
            	        {
            	        	PushFollow(FOLLOW_typer_in_categorySingleComp2275);
            	        	typer156 = typer();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typer156.Tree);

            	        }
            	        break;
            	    case 11 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:90: typej
            	        {
            	        	PushFollow(FOLLOW_typej_in_categorySingleComp2279);
            	        	typej157 = typej();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typej157.Tree);

            	        }
            	        break;
            	    case 12 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:98: typec
            	        {
            	        	PushFollow(FOLLOW_typec_in_categorySingleComp2283);
            	        	typec158 = typec();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typec158.Tree);

            	        }
            	        break;
            	    case 13 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:106: types
            	        {
            	        	PushFollow(FOLLOW_types_in_categorySingleComp2287);
            	        	types159 = types();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, types159.Tree);

            	        }
            	        break;
            	    case 14 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:114: typeabs
            	        {
            	        	PushFollow(FOLLOW_typeabs_in_categorySingleComp2291);
            	        	typeabs160 = typeabs();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typeabs160.Tree);

            	        }
            	        break;
            	    case 15 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:310:124: typeu25
            	        {
            	        	PushFollow(FOLLOW_typeu25_in_categorySingleComp2295);
            	        	typeu25161 = typeu25();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typeu25161.Tree);

            	        }
            	        break;
            	    case 16 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:311:3: typem25
            	        {
            	        	PushFollow(FOLLOW_typem25_in_categorySingleComp2301);
            	        	typem25162 = typem25();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typem25162.Tree);

            	        }
            	        break;
            	    case 17 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:311:12: typem30
            	        {
            	        	PushFollow(FOLLOW_typem30_in_categorySingleComp2304);
            	        	typem30163 = typem30();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typem30163.Tree);

            	        }
            	        break;
            	    case 18 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:311:22: typem35
            	        {
            	        	PushFollow(FOLLOW_typem35_in_categorySingleComp2308);
            	        	typem35164 = typem35();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typem35164.Tree);

            	        }
            	        break;
            	    case 19 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:311:32: typem40
            	        {
            	        	PushFollow(FOLLOW_typem40_in_categorySingleComp2312);
            	        	typem40165 = typem40();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typem40165.Tree);

            	        }
            	        break;
            	    case 20 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:311:42: typem45
            	        {
            	        	PushFollow(FOLLOW_typem45_in_categorySingleComp2316);
            	        	typem45166 = typem45();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typem45166.Tree);

            	        }
            	        break;
            	    case 21 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:311:52: typem50
            	        {
            	        	PushFollow(FOLLOW_typem50_in_categorySingleComp2320);
            	        	typem50167 = typem50();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typem50167.Tree);

            	        }
            	        break;
            	    case 22 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:311:62: typem55
            	        {
            	        	PushFollow(FOLLOW_typem55_in_categorySingleComp2324);
            	        	typem55168 = typem55();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typem55168.Tree);

            	        }
            	        break;
            	    case 23 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:311:72: typem60
            	        {
            	        	PushFollow(FOLLOW_typem60_in_categorySingleComp2328);
            	        	typem60169 = typem60();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typem60169.Tree);

            	        }
            	        break;
            	    case 24 :
            	        // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:311:82: typem65
            	        {
            	        	PushFollow(FOLLOW_typem65_in_categorySingleComp2332);
            	        	typem65170 = typem65();
            	        	state.followingStackPointer--;

            	        	adaptor.AddChild(root_0, typem65170.Tree);

            	        }
            	        break;

            	}


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "categorySingleComp"

    public class typeesa_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typeesa"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:312:1: typeesa : TYPEESA ;
    public SwimmingCompetitionGrammarParser.typeesa_return typeesa() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typeesa_return retval = new SwimmingCompetitionGrammarParser.typeesa_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEESA171 = null;

        CommonTree TYPEESA171_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:312:9: ( TYPEESA )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:312:11: TYPEESA
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEESA171=(IToken)Match(input,TYPEESA,FOLLOW_TYPEESA_in_typeesa2340); 
            		TYPEESA171_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEESA171) ;
            		adaptor.AddChild(root_0, TYPEESA171_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typeesa"

    public class typeesb_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typeesb"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:313:1: typeesb : TYPEESB ;
    public SwimmingCompetitionGrammarParser.typeesb_return typeesb() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typeesb_return retval = new SwimmingCompetitionGrammarParser.typeesb_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEESB172 = null;

        CommonTree TYPEESB172_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:313:9: ( TYPEESB )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:313:11: TYPEESB
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEESB172=(IToken)Match(input,TYPEESB,FOLLOW_TYPEESB_in_typeesb2354); 
            		TYPEESB172_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEESB172) ;
            		adaptor.AddChild(root_0, TYPEESB172_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typeesb"

    public class typep1_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typep1"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:314:1: typep1 : TYPEP1 ;
    public SwimmingCompetitionGrammarParser.typep1_return typep1() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typep1_return retval = new SwimmingCompetitionGrammarParser.typep1_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEP1173 = null;

        CommonTree TYPEP1173_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:314:8: ( TYPEP1 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:314:10: TYPEP1
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEP1173=(IToken)Match(input,TYPEP1,FOLLOW_TYPEP1_in_typep12368); 
            		TYPEP1173_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEP1173) ;
            		adaptor.AddChild(root_0, TYPEP1173_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typep1"

    public class typep2_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typep2"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:315:1: typep2 : TYPEP2 ;
    public SwimmingCompetitionGrammarParser.typep2_return typep2() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typep2_return retval = new SwimmingCompetitionGrammarParser.typep2_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEP2174 = null;

        CommonTree TYPEP2174_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:315:8: ( TYPEP2 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:315:10: TYPEP2
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEP2174=(IToken)Match(input,TYPEP2,FOLLOW_TYPEP2_in_typep22382); 
            		TYPEP2174_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEP2174) ;
            		adaptor.AddChild(root_0, TYPEP2174_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typep2"

    public class typep3_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typep3"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:316:1: typep3 : TYPEP3 ;
    public SwimmingCompetitionGrammarParser.typep3_return typep3() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typep3_return retval = new SwimmingCompetitionGrammarParser.typep3_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEP3175 = null;

        CommonTree TYPEP3175_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:316:8: ( TYPEP3 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:316:10: TYPEP3
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEP3175=(IToken)Match(input,TYPEP3,FOLLOW_TYPEP3_in_typep32396); 
            		TYPEP3175_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEP3175) ;
            		adaptor.AddChild(root_0, TYPEP3175_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typep3"

    public class typep4_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typep4"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:317:1: typep4 : TYPEP4 ;
    public SwimmingCompetitionGrammarParser.typep4_return typep4() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typep4_return retval = new SwimmingCompetitionGrammarParser.typep4_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEP4176 = null;

        CommonTree TYPEP4176_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:317:8: ( TYPEP4 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:317:10: TYPEP4
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEP4176=(IToken)Match(input,TYPEP4,FOLLOW_TYPEP4_in_typep42410); 
            		TYPEP4176_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEP4176) ;
            		adaptor.AddChild(root_0, TYPEP4176_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typep4"

    public class typep5_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typep5"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:318:1: typep5 : TYPEP5 ;
    public SwimmingCompetitionGrammarParser.typep5_return typep5() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typep5_return retval = new SwimmingCompetitionGrammarParser.typep5_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEP5177 = null;

        CommonTree TYPEP5177_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:318:8: ( TYPEP5 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:318:10: TYPEP5
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEP5177=(IToken)Match(input,TYPEP5,FOLLOW_TYPEP5_in_typep52424); 
            		TYPEP5177_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEP5177) ;
            		adaptor.AddChild(root_0, TYPEP5177_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typep5"

    public class typep6_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typep6"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:319:1: typep6 : TYPEP6 ;
    public SwimmingCompetitionGrammarParser.typep6_return typep6() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typep6_return retval = new SwimmingCompetitionGrammarParser.typep6_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEP6178 = null;

        CommonTree TYPEP6178_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:319:8: ( TYPEP6 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:319:10: TYPEP6
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEP6178=(IToken)Match(input,TYPEP6,FOLLOW_TYPEP6_in_typep62438); 
            		TYPEP6178_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEP6178) ;
            		adaptor.AddChild(root_0, TYPEP6178_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typep6"

    public class typep7_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typep7"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:320:1: typep7 : TYPEP7 ;
    public SwimmingCompetitionGrammarParser.typep7_return typep7() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typep7_return retval = new SwimmingCompetitionGrammarParser.typep7_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEP7179 = null;

        CommonTree TYPEP7179_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:320:8: ( TYPEP7 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:320:10: TYPEP7
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEP7179=(IToken)Match(input,TYPEP7,FOLLOW_TYPEP7_in_typep72452); 
            		TYPEP7179_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEP7179) ;
            		adaptor.AddChild(root_0, TYPEP7179_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typep7"

    public class typer_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typer"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:321:1: typer : TYPER ;
    public SwimmingCompetitionGrammarParser.typer_return typer() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typer_return retval = new SwimmingCompetitionGrammarParser.typer_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPER180 = null;

        CommonTree TYPER180_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:321:7: ( TYPER )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:321:9: TYPER
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPER180=(IToken)Match(input,TYPER,FOLLOW_TYPER_in_typer2466); 
            		TYPER180_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPER180) ;
            		adaptor.AddChild(root_0, TYPER180_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typer"

    public class typej_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typej"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:322:1: typej : TYPEJ ;
    public SwimmingCompetitionGrammarParser.typej_return typej() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typej_return retval = new SwimmingCompetitionGrammarParser.typej_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEJ181 = null;

        CommonTree TYPEJ181_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:322:7: ( TYPEJ )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:322:9: TYPEJ
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEJ181=(IToken)Match(input,TYPEJ,FOLLOW_TYPEJ_in_typej2480); 
            		TYPEJ181_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEJ181) ;
            		adaptor.AddChild(root_0, TYPEJ181_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typej"

    public class typec_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typec"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:323:1: typec : TYPEC ;
    public SwimmingCompetitionGrammarParser.typec_return typec() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typec_return retval = new SwimmingCompetitionGrammarParser.typec_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEC182 = null;

        CommonTree TYPEC182_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:323:8: ( TYPEC )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:323:10: TYPEC
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEC182=(IToken)Match(input,TYPEC,FOLLOW_TYPEC_in_typec2495); 
            		TYPEC182_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEC182) ;
            		adaptor.AddChild(root_0, TYPEC182_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typec"

    public class types_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "types"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:324:1: types : TYPES ;
    public SwimmingCompetitionGrammarParser.types_return types() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.types_return retval = new SwimmingCompetitionGrammarParser.types_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPES183 = null;

        CommonTree TYPES183_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:324:7: ( TYPES )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:324:9: TYPES
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPES183=(IToken)Match(input,TYPES,FOLLOW_TYPES_in_types2509); 
            		TYPES183_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPES183) ;
            		adaptor.AddChild(root_0, TYPES183_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "types"

    public class typeabs_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typeabs"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:325:1: typeabs : TYPEABS ;
    public SwimmingCompetitionGrammarParser.typeabs_return typeabs() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typeabs_return retval = new SwimmingCompetitionGrammarParser.typeabs_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEABS184 = null;

        CommonTree TYPEABS184_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:325:9: ( TYPEABS )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:325:11: TYPEABS
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEABS184=(IToken)Match(input,TYPEABS,FOLLOW_TYPEABS_in_typeabs2523); 
            		TYPEABS184_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEABS184) ;
            		adaptor.AddChild(root_0, TYPEABS184_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typeabs"

    public class typeu25_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typeu25"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:326:1: typeu25 : TYPEU25 ;
    public SwimmingCompetitionGrammarParser.typeu25_return typeu25() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typeu25_return retval = new SwimmingCompetitionGrammarParser.typeu25_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEU25185 = null;

        CommonTree TYPEU25185_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:326:9: ( TYPEU25 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:326:11: TYPEU25
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEU25185=(IToken)Match(input,TYPEU25,FOLLOW_TYPEU25_in_typeu252537); 
            		TYPEU25185_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEU25185) ;
            		adaptor.AddChild(root_0, TYPEU25185_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typeu25"

    public class typem25_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typem25"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:327:1: typem25 : TYPEM25 ;
    public SwimmingCompetitionGrammarParser.typem25_return typem25() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typem25_return retval = new SwimmingCompetitionGrammarParser.typem25_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEM25186 = null;

        CommonTree TYPEM25186_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:327:9: ( TYPEM25 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:327:11: TYPEM25
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEM25186=(IToken)Match(input,TYPEM25,FOLLOW_TYPEM25_in_typem252551); 
            		TYPEM25186_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEM25186) ;
            		adaptor.AddChild(root_0, TYPEM25186_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typem25"

    public class typem30_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typem30"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:328:1: typem30 : TYPEM30 ;
    public SwimmingCompetitionGrammarParser.typem30_return typem30() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typem30_return retval = new SwimmingCompetitionGrammarParser.typem30_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEM30187 = null;

        CommonTree TYPEM30187_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:328:9: ( TYPEM30 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:328:11: TYPEM30
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEM30187=(IToken)Match(input,TYPEM30,FOLLOW_TYPEM30_in_typem302565); 
            		TYPEM30187_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEM30187) ;
            		adaptor.AddChild(root_0, TYPEM30187_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typem30"

    public class typem35_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typem35"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:329:1: typem35 : TYPEM35 ;
    public SwimmingCompetitionGrammarParser.typem35_return typem35() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typem35_return retval = new SwimmingCompetitionGrammarParser.typem35_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEM35188 = null;

        CommonTree TYPEM35188_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:329:9: ( TYPEM35 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:329:11: TYPEM35
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEM35188=(IToken)Match(input,TYPEM35,FOLLOW_TYPEM35_in_typem352579); 
            		TYPEM35188_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEM35188) ;
            		adaptor.AddChild(root_0, TYPEM35188_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typem35"

    public class typem40_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typem40"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:330:1: typem40 : TYPEM40 ;
    public SwimmingCompetitionGrammarParser.typem40_return typem40() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typem40_return retval = new SwimmingCompetitionGrammarParser.typem40_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEM40189 = null;

        CommonTree TYPEM40189_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:330:9: ( TYPEM40 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:330:11: TYPEM40
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEM40189=(IToken)Match(input,TYPEM40,FOLLOW_TYPEM40_in_typem402593); 
            		TYPEM40189_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEM40189) ;
            		adaptor.AddChild(root_0, TYPEM40189_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typem40"

    public class typem45_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typem45"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:331:1: typem45 : TYPEM45 ;
    public SwimmingCompetitionGrammarParser.typem45_return typem45() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typem45_return retval = new SwimmingCompetitionGrammarParser.typem45_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEM45190 = null;

        CommonTree TYPEM45190_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:331:9: ( TYPEM45 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:331:11: TYPEM45
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEM45190=(IToken)Match(input,TYPEM45,FOLLOW_TYPEM45_in_typem452607); 
            		TYPEM45190_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEM45190) ;
            		adaptor.AddChild(root_0, TYPEM45190_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typem45"

    public class typem50_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typem50"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:332:1: typem50 : TYPEM50 ;
    public SwimmingCompetitionGrammarParser.typem50_return typem50() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typem50_return retval = new SwimmingCompetitionGrammarParser.typem50_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEM50191 = null;

        CommonTree TYPEM50191_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:332:9: ( TYPEM50 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:332:11: TYPEM50
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEM50191=(IToken)Match(input,TYPEM50,FOLLOW_TYPEM50_in_typem502621); 
            		TYPEM50191_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEM50191) ;
            		adaptor.AddChild(root_0, TYPEM50191_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typem50"

    public class typem55_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typem55"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:333:1: typem55 : TYPEM55 ;
    public SwimmingCompetitionGrammarParser.typem55_return typem55() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typem55_return retval = new SwimmingCompetitionGrammarParser.typem55_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEM55192 = null;

        CommonTree TYPEM55192_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:333:9: ( TYPEM55 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:333:11: TYPEM55
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEM55192=(IToken)Match(input,TYPEM55,FOLLOW_TYPEM55_in_typem552635); 
            		TYPEM55192_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEM55192) ;
            		adaptor.AddChild(root_0, TYPEM55192_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typem55"

    public class typem60_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typem60"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:334:1: typem60 : TYPEM60 ;
    public SwimmingCompetitionGrammarParser.typem60_return typem60() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typem60_return retval = new SwimmingCompetitionGrammarParser.typem60_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEM60193 = null;

        CommonTree TYPEM60193_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:334:9: ( TYPEM60 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:334:11: TYPEM60
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEM60193=(IToken)Match(input,TYPEM60,FOLLOW_TYPEM60_in_typem602649); 
            		TYPEM60193_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEM60193) ;
            		adaptor.AddChild(root_0, TYPEM60193_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typem60"

    public class typem65_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typem65"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:335:1: typem65 : TYPEM65 ;
    public SwimmingCompetitionGrammarParser.typem65_return typem65() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typem65_return retval = new SwimmingCompetitionGrammarParser.typem65_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken TYPEM65194 = null;

        CommonTree TYPEM65194_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:335:9: ( TYPEM65 )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:335:11: TYPEM65
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	TYPEM65194=(IToken)Match(input,TYPEM65,FOLLOW_TYPEM65_in_typem652663); 
            		TYPEM65194_tree = new SwimmingCompetition.AST.CategoryCompNode(TYPEM65194) ;
            		adaptor.AddChild(root_0, TYPEM65194_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "CATEGORY COMPETITION of DAY");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typem65"

    public class typeturncomp_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "typeturncomp"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:337:1: typeturncomp : ( heats | fin | semfin );
    public SwimmingCompetitionGrammarParser.typeturncomp_return typeturncomp() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.typeturncomp_return retval = new SwimmingCompetitionGrammarParser.typeturncomp_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        SwimmingCompetitionGrammarParser.heats_return heats195 = default(SwimmingCompetitionGrammarParser.heats_return);

        SwimmingCompetitionGrammarParser.fin_return fin196 = default(SwimmingCompetitionGrammarParser.fin_return);

        SwimmingCompetitionGrammarParser.semfin_return semfin197 = default(SwimmingCompetitionGrammarParser.semfin_return);



        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:338:2: ( heats | fin | semfin )
            int alt7 = 3;
            switch ( input.LA(1) ) 
            {
            case HEATS:
            	{
                alt7 = 1;
                }
                break;
            case FIN:
            	{
                alt7 = 2;
                }
                break;
            case SEMFIN:
            	{
                alt7 = 3;
                }
                break;
            	default:
            	    NoViableAltException nvae_d7s0 =
            	        new NoViableAltException("", 7, 0, input);

            	    throw nvae_d7s0;
            }

            switch (alt7) 
            {
                case 1 :
                    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:339:2: heats
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_heats_in_typeturncomp2681);
                    	heats195 = heats();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, heats195.Tree);

                    }
                    break;
                case 2 :
                    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:339:10: fin
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_fin_in_typeturncomp2685);
                    	fin196 = fin();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, fin196.Tree);

                    }
                    break;
                case 3 :
                    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:339:16: semfin
                    {
                    	root_0 = (CommonTree)adaptor.GetNilNode();

                    	PushFollow(FOLLOW_semfin_in_typeturncomp2689);
                    	semfin197 = semfin();
                    	state.followingStackPointer--;

                    	adaptor.AddChild(root_0, semfin197.Tree);

                    }
                    break;

            }
            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "TYPETURNCOMP");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "typeturncomp"

    public class heats_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "heats"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:341:1: heats : HEATS ;
    public SwimmingCompetitionGrammarParser.heats_return heats() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.heats_return retval = new SwimmingCompetitionGrammarParser.heats_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken HEATS198 = null;

        CommonTree HEATS198_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:341:8: ( HEATS )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:342:2: HEATS
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	HEATS198=(IToken)Match(input,HEATS,FOLLOW_HEATS_in_heats2699); 
            		HEATS198_tree = new SwimmingCompetition.AST.TurnCompNode(HEATS198) ;
            		adaptor.AddChild(root_0, HEATS198_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "TYPETURNCOMP");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "heats"

    public class fin_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "fin"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:343:1: fin : FIN ;
    public SwimmingCompetitionGrammarParser.fin_return fin() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.fin_return retval = new SwimmingCompetitionGrammarParser.fin_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken FIN199 = null;

        CommonTree FIN199_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:343:6: ( FIN )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:344:2: FIN
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	FIN199=(IToken)Match(input,FIN,FOLLOW_FIN_in_fin2715); 
            		FIN199_tree = new SwimmingCompetition.AST.TurnCompNode(FIN199) ;
            		adaptor.AddChild(root_0, FIN199_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);
        throw new ErrorNodeException("", "TYPETURNCOMP");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "fin"

    public class semfin_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "semfin"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:345:1: semfin : SEMFIN ;
    public SwimmingCompetitionGrammarParser.semfin_return semfin() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.semfin_return retval = new SwimmingCompetitionGrammarParser.semfin_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken SEMFIN200 = null;

        CommonTree SEMFIN200_tree=null;

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:345:9: ( SEMFIN )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:346:2: SEMFIN
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	SEMFIN200=(IToken)Match(input,SEMFIN,FOLLOW_SEMFIN_in_semfin2732); 
            		SEMFIN200_tree = new SwimmingCompetition.AST.TurnCompNode(SEMFIN200) ;
            		adaptor.AddChild(root_0, SEMFIN200_tree);


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "TYPETURNCOMP");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "semfin"

    public class startlist_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "startlist"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:348:1: startlist : STARTLIST A_GR ( singlecomp )+ C_GR -> ^( STARTLIST ( singlecomp )+ ) ;
    public SwimmingCompetitionGrammarParser.startlist_return startlist() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.startlist_return retval = new SwimmingCompetitionGrammarParser.startlist_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken STARTLIST201 = null;
        IToken A_GR202 = null;
        IToken C_GR204 = null;
        SwimmingCompetitionGrammarParser.singlecomp_return singlecomp203 = default(SwimmingCompetitionGrammarParser.singlecomp_return);


        CommonTree STARTLIST201_tree=null;
        CommonTree A_GR202_tree=null;
        CommonTree C_GR204_tree=null;
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleTokenStream stream_STARTLIST = new RewriteRuleTokenStream(adaptor,"token STARTLIST");
        RewriteRuleSubtreeStream stream_singlecomp = new RewriteRuleSubtreeStream(adaptor,"rule singlecomp");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:349:2: ( STARTLIST A_GR ( singlecomp )+ C_GR -> ^( STARTLIST ( singlecomp )+ ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:350:2: STARTLIST A_GR ( singlecomp )+ C_GR
            {
            	STARTLIST201=(IToken)Match(input,STARTLIST,FOLLOW_STARTLIST_in_startlist2752);  
            	stream_STARTLIST.Add(STARTLIST201);

            	A_GR202=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_startlist2755);  
            	stream_A_GR.Add(A_GR202);

            	// C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:352:3: ( singlecomp )+
            	int cnt8 = 0;
            	do 
            	{
            	    int alt8 = 2;
            	    int LA8_0 = input.LA(1);

            	    if ( (LA8_0 == COMPNAME) )
            	    {
            	        alt8 = 1;
            	    }


            	    switch (alt8) 
            		{
            			case 1 :
            			    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:352:4: singlecomp
            			    {
            			    	PushFollow(FOLLOW_singlecomp_in_startlist2760);
            			    	singlecomp203 = singlecomp();
            			    	state.followingStackPointer--;

            			    	stream_singlecomp.Add(singlecomp203.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt8 >= 1 ) goto loop8;
            		            EarlyExitException eee8 =
            		                new EarlyExitException(8, input);
            		            throw eee8;
            	    }
            	    cnt8++;
            	} while (true);

            	loop8:
            		;	// Stops C# compiler whining that label 'loop8' has no statements

            	C_GR204=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_startlist2765);  
            	stream_C_GR.Add(C_GR204);



            	// AST REWRITE
            	// elements:          singlecomp, STARTLIST
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 354:2: -> ^( STARTLIST ( singlecomp )+ )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:354:5: ^( STARTLIST ( singlecomp )+ )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.StartListNode(stream_STARTLIST.NextToken()), root_1);

            	    if ( !(stream_singlecomp.HasNext()) ) {
            	        throw new RewriteEarlyExitException();
            	    }
            	    while ( stream_singlecomp.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_singlecomp.NextTree());

            	    }
            	    stream_singlecomp.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "STARTLIST");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "startlist"

    public class singlecomp_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "singlecomp"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:357:1: singlecomp : COMPNAME ':' STRING A_GR ( turn )+ C_GR -> ^( STRING ( turn )+ ) ;
    public SwimmingCompetitionGrammarParser.singlecomp_return singlecomp() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.singlecomp_return retval = new SwimmingCompetitionGrammarParser.singlecomp_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken COMPNAME205 = null;
        IToken char_literal206 = null;
        IToken STRING207 = null;
        IToken A_GR208 = null;
        IToken C_GR210 = null;
        SwimmingCompetitionGrammarParser.turn_return turn209 = default(SwimmingCompetitionGrammarParser.turn_return);


        CommonTree COMPNAME205_tree=null;
        CommonTree char_literal206_tree=null;
        CommonTree STRING207_tree=null;
        CommonTree A_GR208_tree=null;
        CommonTree C_GR210_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_COMPNAME = new RewriteRuleTokenStream(adaptor,"token COMPNAME");
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");
        RewriteRuleSubtreeStream stream_turn = new RewriteRuleSubtreeStream(adaptor,"rule turn");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:358:2: ( COMPNAME ':' STRING A_GR ( turn )+ C_GR -> ^( STRING ( turn )+ ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:359:2: COMPNAME ':' STRING A_GR ( turn )+ C_GR
            {
            	COMPNAME205=(IToken)Match(input,COMPNAME,FOLLOW_COMPNAME_in_singlecomp2797);  
            	stream_COMPNAME.Add(COMPNAME205);

            	char_literal206=(IToken)Match(input,97,FOLLOW_97_in_singlecomp2799);  
            	stream_97.Add(char_literal206);

            	STRING207=(IToken)Match(input,STRING,FOLLOW_STRING_in_singlecomp2801);  
            	stream_STRING.Add(STRING207);

            	A_GR208=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_singlecomp2805);  
            	stream_A_GR.Add(A_GR208);

            	// C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:361:3: ( turn )+
            	int cnt9 = 0;
            	do 
            	{
            	    int alt9 = 2;
            	    int LA9_0 = input.LA(1);

            	    if ( ((LA9_0 >= HEATS && LA9_0 <= SEMFIN)) )
            	    {
            	        alt9 = 1;
            	    }


            	    switch (alt9) 
            		{
            			case 1 :
            			    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:361:4: turn
            			    {
            			    	PushFollow(FOLLOW_turn_in_singlecomp2810);
            			    	turn209 = turn();
            			    	state.followingStackPointer--;

            			    	stream_turn.Add(turn209.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt9 >= 1 ) goto loop9;
            		            EarlyExitException eee9 =
            		                new EarlyExitException(9, input);
            		            throw eee9;
            	    }
            	    cnt9++;
            	} while (true);

            	loop9:
            		;	// Stops C# compiler whining that label 'loop9' has no statements

            	C_GR210=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_singlecomp2815);  
            	stream_C_GR.Add(C_GR210);



            	// AST REWRITE
            	// elements:          turn, STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 363:2: -> ^( STRING ( turn )+ )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:363:5: ^( STRING ( turn )+ )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.CompNameNode(stream_STRING.NextToken()), root_1);

            	    if ( !(stream_turn.HasNext()) ) {
            	        throw new RewriteEarlyExitException();
            	    }
            	    while ( stream_turn.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_turn.NextTree());

            	    }
            	    stream_turn.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "SINGLECOMP of STARTLIST");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "singlecomp"

    public class turn_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "turn"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:371:1: turn : nameturn A_GR ( startathlete )+ C_GR -> ^( nameturn ( startathlete )+ ) ;
    public SwimmingCompetitionGrammarParser.turn_return turn() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.turn_return retval = new SwimmingCompetitionGrammarParser.turn_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken A_GR212 = null;
        IToken C_GR214 = null;
        SwimmingCompetitionGrammarParser.nameturn_return nameturn211 = default(SwimmingCompetitionGrammarParser.nameturn_return);

        SwimmingCompetitionGrammarParser.startathlete_return startathlete213 = default(SwimmingCompetitionGrammarParser.startathlete_return);


        CommonTree A_GR212_tree=null;
        CommonTree C_GR214_tree=null;
        RewriteRuleTokenStream stream_A_GR = new RewriteRuleTokenStream(adaptor,"token A_GR");
        RewriteRuleTokenStream stream_C_GR = new RewriteRuleTokenStream(adaptor,"token C_GR");
        RewriteRuleSubtreeStream stream_nameturn = new RewriteRuleSubtreeStream(adaptor,"rule nameturn");
        RewriteRuleSubtreeStream stream_startathlete = new RewriteRuleSubtreeStream(adaptor,"rule startathlete");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:371:6: ( nameturn A_GR ( startathlete )+ C_GR -> ^( nameturn ( startathlete )+ ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:372:2: nameturn A_GR ( startathlete )+ C_GR
            {
            	PushFollow(FOLLOW_nameturn_in_turn2847);
            	nameturn211 = nameturn();
            	state.followingStackPointer--;

            	stream_nameturn.Add(nameturn211.Tree);
            	A_GR212=(IToken)Match(input,A_GR,FOLLOW_A_GR_in_turn2850);  
            	stream_A_GR.Add(A_GR212);

            	// C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:374:2: ( startathlete )+
            	int cnt10 = 0;
            	do 
            	{
            	    int alt10 = 2;
            	    int LA10_0 = input.LA(1);

            	    if ( (LA10_0 == A_Q) )
            	    {
            	        alt10 = 1;
            	    }


            	    switch (alt10) 
            		{
            			case 1 :
            			    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:374:3: startathlete
            			    {
            			    	PushFollow(FOLLOW_startathlete_in_turn2854);
            			    	startathlete213 = startathlete();
            			    	state.followingStackPointer--;

            			    	stream_startathlete.Add(startathlete213.Tree);

            			    }
            			    break;

            			default:
            			    if ( cnt10 >= 1 ) goto loop10;
            		            EarlyExitException eee10 =
            		                new EarlyExitException(10, input);
            		            throw eee10;
            	    }
            	    cnt10++;
            	} while (true);

            	loop10:
            		;	// Stops C# compiler whining that label 'loop10' has no statements

            	C_GR214=(IToken)Match(input,C_GR,FOLLOW_C_GR_in_turn2859);  
            	stream_C_GR.Add(C_GR214);



            	// AST REWRITE
            	// elements:          nameturn, startathlete
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 376:2: -> ^( nameturn ( startathlete )+ )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:376:5: ^( nameturn ( startathlete )+ )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_nameturn.NextNode(), root_1);

            	    if ( !(stream_startathlete.HasNext()) ) {
            	        throw new RewriteEarlyExitException();
            	    }
            	    while ( stream_startathlete.HasNext() )
            	    {
            	        adaptor.AddChild(root_1, stream_startathlete.NextTree());

            	    }
            	    stream_startathlete.Reset();

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "TURN of COMP of STARTLIST");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "turn"

    public class nameturn_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "nameturn"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:379:1: nameturn : typeturncomp INT -> ^( typeturncomp INT ) ;
    public SwimmingCompetitionGrammarParser.nameturn_return nameturn() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.nameturn_return retval = new SwimmingCompetitionGrammarParser.nameturn_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken INT216 = null;
        SwimmingCompetitionGrammarParser.typeturncomp_return typeturncomp215 = default(SwimmingCompetitionGrammarParser.typeturncomp_return);


        CommonTree INT216_tree=null;
        RewriteRuleTokenStream stream_INT = new RewriteRuleTokenStream(adaptor,"token INT");
        RewriteRuleSubtreeStream stream_typeturncomp = new RewriteRuleSubtreeStream(adaptor,"rule typeturncomp");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:379:9: ( typeturncomp INT -> ^( typeturncomp INT ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:379:11: typeturncomp INT
            {
            	PushFollow(FOLLOW_typeturncomp_in_nameturn2881);
            	typeturncomp215 = typeturncomp();
            	state.followingStackPointer--;

            	stream_typeturncomp.Add(typeturncomp215.Tree);
            	INT216=(IToken)Match(input,INT,FOLLOW_INT_in_nameturn2883);  
            	stream_INT.Add(INT216);



            	// AST REWRITE
            	// elements:          typeturncomp, INT
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 379:28: -> ^( typeturncomp INT )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:379:32: ^( typeturncomp INT )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(stream_typeturncomp.NextNode(), root_1);

            	    adaptor.AddChild(root_1, new SwimmingCompetition.AST.NumberTypeComp(stream_INT.NextToken()));

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "NAMETURN of COMP of STARTLIST");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "nameturn"

    public class startathlete_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "startathlete"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:381:1: startathlete : A_Q LANE ':' INT athlete C_Q -> ^( INT athlete ) ;
    public SwimmingCompetitionGrammarParser.startathlete_return startathlete() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.startathlete_return retval = new SwimmingCompetitionGrammarParser.startathlete_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken A_Q217 = null;
        IToken LANE218 = null;
        IToken char_literal219 = null;
        IToken INT220 = null;
        IToken C_Q222 = null;
        SwimmingCompetitionGrammarParser.athlete_return athlete221 = default(SwimmingCompetitionGrammarParser.athlete_return);


        CommonTree A_Q217_tree=null;
        CommonTree LANE218_tree=null;
        CommonTree char_literal219_tree=null;
        CommonTree INT220_tree=null;
        CommonTree C_Q222_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_INT = new RewriteRuleTokenStream(adaptor,"token INT");
        RewriteRuleTokenStream stream_LANE = new RewriteRuleTokenStream(adaptor,"token LANE");
        RewriteRuleTokenStream stream_A_Q = new RewriteRuleTokenStream(adaptor,"token A_Q");
        RewriteRuleTokenStream stream_C_Q = new RewriteRuleTokenStream(adaptor,"token C_Q");
        RewriteRuleSubtreeStream stream_athlete = new RewriteRuleSubtreeStream(adaptor,"rule athlete");
        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:382:2: ( A_Q LANE ':' INT athlete C_Q -> ^( INT athlete ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:382:4: A_Q LANE ':' INT athlete C_Q
            {
            	A_Q217=(IToken)Match(input,A_Q,FOLLOW_A_Q_in_startathlete2908);  
            	stream_A_Q.Add(A_Q217);

            	LANE218=(IToken)Match(input,LANE,FOLLOW_LANE_in_startathlete2912);  
            	stream_LANE.Add(LANE218);

            	char_literal219=(IToken)Match(input,97,FOLLOW_97_in_startathlete2914);  
            	stream_97.Add(char_literal219);

            	INT220=(IToken)Match(input,INT,FOLLOW_INT_in_startathlete2916);  
            	stream_INT.Add(INT220);

            	PushFollow(FOLLOW_athlete_in_startathlete2920);
            	athlete221 = athlete();
            	state.followingStackPointer--;

            	stream_athlete.Add(athlete221.Tree);
            	C_Q222=(IToken)Match(input,C_Q,FOLLOW_C_Q_in_startathlete2924);  
            	stream_C_Q.Add(C_Q222);



            	// AST REWRITE
            	// elements:          INT, athlete
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 386:2: -> ^( INT athlete )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:386:6: ^( INT athlete )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.LaneNode(stream_INT.NextToken()), root_1);

            	    adaptor.AddChild(root_1, stream_athlete.NextTree());

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "ATHLETE of STARTLIST");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "startathlete"

    public class athlete_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "athlete"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:388:1: athlete : acode aname asurname asoc abirth atimereg atimeres ;
    public SwimmingCompetitionGrammarParser.athlete_return athlete() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.athlete_return retval = new SwimmingCompetitionGrammarParser.athlete_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        SwimmingCompetitionGrammarParser.acode_return acode223 = default(SwimmingCompetitionGrammarParser.acode_return);

        SwimmingCompetitionGrammarParser.aname_return aname224 = default(SwimmingCompetitionGrammarParser.aname_return);

        SwimmingCompetitionGrammarParser.asurname_return asurname225 = default(SwimmingCompetitionGrammarParser.asurname_return);

        SwimmingCompetitionGrammarParser.asoc_return asoc226 = default(SwimmingCompetitionGrammarParser.asoc_return);

        SwimmingCompetitionGrammarParser.abirth_return abirth227 = default(SwimmingCompetitionGrammarParser.abirth_return);

        SwimmingCompetitionGrammarParser.atimereg_return atimereg228 = default(SwimmingCompetitionGrammarParser.atimereg_return);

        SwimmingCompetitionGrammarParser.atimeres_return atimeres229 = default(SwimmingCompetitionGrammarParser.atimeres_return);



        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:389:2: ( acode aname asurname asoc abirth atimereg atimeres )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:390:2: acode aname asurname asoc abirth atimereg atimeres
            {
            	root_0 = (CommonTree)adaptor.GetNilNode();

            	PushFollow(FOLLOW_acode_in_athlete2951);
            	acode223 = acode();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, acode223.Tree);
            	PushFollow(FOLLOW_aname_in_athlete2954);
            	aname224 = aname();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, aname224.Tree);
            	PushFollow(FOLLOW_asurname_in_athlete2957);
            	asurname225 = asurname();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, asurname225.Tree);
            	PushFollow(FOLLOW_asoc_in_athlete2960);
            	asoc226 = asoc();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, asoc226.Tree);
            	PushFollow(FOLLOW_abirth_in_athlete2963);
            	abirth227 = abirth();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, abirth227.Tree);
            	PushFollow(FOLLOW_atimereg_in_athlete2966);
            	atimereg228 = atimereg();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, atimereg228.Tree);
            	PushFollow(FOLLOW_atimeres_in_athlete2969);
            	atimeres229 = atimeres();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, atimeres229.Tree);

            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "ATHLETE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "athlete"

    public class acode_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "acode"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:399:1: acode : ACODE ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.acode_return acode() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.acode_return retval = new SwimmingCompetitionGrammarParser.acode_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ACODE230 = null;
        IToken char_literal231 = null;
        IToken STRING232 = null;

        CommonTree ACODE230_tree=null;
        CommonTree char_literal231_tree=null;
        CommonTree STRING232_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_ACODE = new RewriteRuleTokenStream(adaptor,"token ACODE");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:399:7: ( ACODE ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:399:9: ACODE ':' STRING
            {
            	ACODE230=(IToken)Match(input,ACODE,FOLLOW_ACODE_in_acode2980);  
            	stream_ACODE.Add(ACODE230);

            	char_literal231=(IToken)Match(input,97,FOLLOW_97_in_acode2982);  
            	stream_97.Add(char_literal231);

            	STRING232=(IToken)Match(input,STRING,FOLLOW_STRING_in_acode2984);  
            	stream_STRING.Add(STRING232);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 399:26: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:399:29: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.ACode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "ACODE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "acode"

    public class aname_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "aname"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:400:1: aname : ANAME ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.aname_return aname() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.aname_return retval = new SwimmingCompetitionGrammarParser.aname_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ANAME233 = null;
        IToken char_literal234 = null;
        IToken STRING235 = null;

        CommonTree ANAME233_tree=null;
        CommonTree char_literal234_tree=null;
        CommonTree STRING235_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_ANAME = new RewriteRuleTokenStream(adaptor,"token ANAME");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:400:7: ( ANAME ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:400:9: ANAME ':' STRING
            {
            	ANAME233=(IToken)Match(input,ANAME,FOLLOW_ANAME_in_aname3004);  
            	stream_ANAME.Add(ANAME233);

            	char_literal234=(IToken)Match(input,97,FOLLOW_97_in_aname3006);  
            	stream_97.Add(char_literal234);

            	STRING235=(IToken)Match(input,STRING,FOLLOW_STRING_in_aname3008);  
            	stream_STRING.Add(STRING235);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 400:26: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:400:29: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.ANameNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "ANAME");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "aname"

    public class asurname_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "asurname"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:401:1: asurname : ASURNNAME ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.asurname_return asurname() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.asurname_return retval = new SwimmingCompetitionGrammarParser.asurname_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ASURNNAME236 = null;
        IToken char_literal237 = null;
        IToken STRING238 = null;

        CommonTree ASURNNAME236_tree=null;
        CommonTree char_literal237_tree=null;
        CommonTree STRING238_tree=null;
        RewriteRuleTokenStream stream_ASURNNAME = new RewriteRuleTokenStream(adaptor,"token ASURNNAME");
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:401:9: ( ASURNNAME ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:401:11: ASURNNAME ':' STRING
            {
            	ASURNNAME236=(IToken)Match(input,ASURNNAME,FOLLOW_ASURNNAME_in_asurname3027);  
            	stream_ASURNNAME.Add(ASURNNAME236);

            	char_literal237=(IToken)Match(input,97,FOLLOW_97_in_asurname3029);  
            	stream_97.Add(char_literal237);

            	STRING238=(IToken)Match(input,STRING,FOLLOW_STRING_in_asurname3031);  
            	stream_STRING.Add(STRING238);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 401:32: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:401:35: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.ASurnameNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "ASURNAME");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "asurname"

    public class asoc_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "asoc"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:402:1: asoc : ASOC ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.asoc_return asoc() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.asoc_return retval = new SwimmingCompetitionGrammarParser.asoc_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ASOC239 = null;
        IToken char_literal240 = null;
        IToken STRING241 = null;

        CommonTree ASOC239_tree=null;
        CommonTree char_literal240_tree=null;
        CommonTree STRING241_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_ASOC = new RewriteRuleTokenStream(adaptor,"token ASOC");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:402:6: ( ASOC ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:402:8: ASOC ':' STRING
            {
            	ASOC239=(IToken)Match(input,ASOC,FOLLOW_ASOC_in_asoc3051);  
            	stream_ASOC.Add(ASOC239);

            	char_literal240=(IToken)Match(input,97,FOLLOW_97_in_asoc3053);  
            	stream_97.Add(char_literal240);

            	STRING241=(IToken)Match(input,STRING,FOLLOW_STRING_in_asoc3055);  
            	stream_STRING.Add(STRING241);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 402:24: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:402:27: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.ASocietyNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "ASOC");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "asoc"

    public class abirth_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "abirth"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:403:1: abirth : ABIRTH ':' DATE -> ^( DATE ) ;
    public SwimmingCompetitionGrammarParser.abirth_return abirth() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.abirth_return retval = new SwimmingCompetitionGrammarParser.abirth_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ABIRTH242 = null;
        IToken char_literal243 = null;
        IToken DATE244 = null;

        CommonTree ABIRTH242_tree=null;
        CommonTree char_literal243_tree=null;
        CommonTree DATE244_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_ABIRTH = new RewriteRuleTokenStream(adaptor,"token ABIRTH");
        RewriteRuleTokenStream stream_DATE = new RewriteRuleTokenStream(adaptor,"token DATE");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:403:9: ( ABIRTH ':' DATE -> ^( DATE ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:403:11: ABIRTH ':' DATE
            {
            	ABIRTH242=(IToken)Match(input,ABIRTH,FOLLOW_ABIRTH_in_abirth3076);  
            	stream_ABIRTH.Add(ABIRTH242);

            	char_literal243=(IToken)Match(input,97,FOLLOW_97_in_abirth3078);  
            	stream_97.Add(char_literal243);

            	DATE244=(IToken)Match(input,DATE,FOLLOW_DATE_in_abirth3080);  
            	stream_DATE.Add(DATE244);



            	// AST REWRITE
            	// elements:          DATE
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 403:27: -> ^( DATE )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:403:30: ^( DATE )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.ABirthdayNode(stream_DATE.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "ABIRTH");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "abirth"

    public class atimereg_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "atimereg"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:404:1: atimereg : ATIMEREG ':' ATIME -> ^( ATIME ) ;
    public SwimmingCompetitionGrammarParser.atimereg_return atimereg() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.atimereg_return retval = new SwimmingCompetitionGrammarParser.atimereg_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ATIMEREG245 = null;
        IToken char_literal246 = null;
        IToken ATIME247 = null;

        CommonTree ATIMEREG245_tree=null;
        CommonTree char_literal246_tree=null;
        CommonTree ATIME247_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_ATIME = new RewriteRuleTokenStream(adaptor,"token ATIME");
        RewriteRuleTokenStream stream_ATIMEREG = new RewriteRuleTokenStream(adaptor,"token ATIMEREG");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:404:9: ( ATIMEREG ':' ATIME -> ^( ATIME ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:404:11: ATIMEREG ':' ATIME
            {
            	ATIMEREG245=(IToken)Match(input,ATIMEREG,FOLLOW_ATIMEREG_in_atimereg3099);  
            	stream_ATIMEREG.Add(ATIMEREG245);

            	char_literal246=(IToken)Match(input,97,FOLLOW_97_in_atimereg3101);  
            	stream_97.Add(char_literal246);

            	ATIME247=(IToken)Match(input,ATIME,FOLLOW_ATIME_in_atimereg3103);  
            	stream_ATIME.Add(ATIME247);



            	// AST REWRITE
            	// elements:          ATIME
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 404:30: -> ^( ATIME )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:404:33: ^( ATIME )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.ATimeRegNode(stream_ATIME.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "ATIMEREG");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "atimereg"

    public class atimeres_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "atimeres"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:405:1: atimeres : ATIMERES ':' ATIME -> ^( ATIME ) ;
    public SwimmingCompetitionGrammarParser.atimeres_return atimeres() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.atimeres_return retval = new SwimmingCompetitionGrammarParser.atimeres_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken ATIMERES248 = null;
        IToken char_literal249 = null;
        IToken ATIME250 = null;

        CommonTree ATIMERES248_tree=null;
        CommonTree char_literal249_tree=null;
        CommonTree ATIME250_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_ATIME = new RewriteRuleTokenStream(adaptor,"token ATIME");
        RewriteRuleTokenStream stream_ATIMERES = new RewriteRuleTokenStream(adaptor,"token ATIMERES");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:405:9: ( ATIMERES ':' ATIME -> ^( ATIME ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:405:11: ATIMERES ':' ATIME
            {
            	ATIMERES248=(IToken)Match(input,ATIMERES,FOLLOW_ATIMERES_in_atimeres3122);  
            	stream_ATIMERES.Add(ATIMERES248);

            	char_literal249=(IToken)Match(input,97,FOLLOW_97_in_atimeres3124);  
            	stream_97.Add(char_literal249);

            	ATIME250=(IToken)Match(input,ATIME,FOLLOW_ATIME_in_atimeres3126);  
            	stream_ATIME.Add(ATIME250);



            	// AST REWRITE
            	// elements:          ATIME
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 405:30: -> ^( ATIME )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:405:33: ^( ATIME )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.ATimeResultNode(stream_ATIME.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "ATIMERES");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "atimeres"

    public class note_return : ParserRuleReturnScope
    {
        private CommonTree tree;
        override public object Tree
        {
        	get { return tree; }
        	set { tree = (CommonTree) value; }
        }
    };

    // $ANTLR start "note"
    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:407:1: note : NOTES ':' STRING -> ^( STRING ) ;
    public SwimmingCompetitionGrammarParser.note_return note() // throws RecognitionException [1]
    {   
        SwimmingCompetitionGrammarParser.note_return retval = new SwimmingCompetitionGrammarParser.note_return();
        retval.Start = input.LT(1);

        CommonTree root_0 = null;

        IToken NOTES251 = null;
        IToken char_literal252 = null;
        IToken STRING253 = null;

        CommonTree NOTES251_tree=null;
        CommonTree char_literal252_tree=null;
        CommonTree STRING253_tree=null;
        RewriteRuleTokenStream stream_97 = new RewriteRuleTokenStream(adaptor,"token 97");
        RewriteRuleTokenStream stream_NOTES = new RewriteRuleTokenStream(adaptor,"token NOTES");
        RewriteRuleTokenStream stream_STRING = new RewriteRuleTokenStream(adaptor,"token STRING");

        try 
    	{
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:407:7: ( NOTES ':' STRING -> ^( STRING ) )
            // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:408:2: NOTES ':' STRING
            {
            	NOTES251=(IToken)Match(input,NOTES,FOLLOW_NOTES_in_note3152);  
            	stream_NOTES.Add(NOTES251);

            	char_literal252=(IToken)Match(input,97,FOLLOW_97_in_note3154);  
            	stream_97.Add(char_literal252);

            	STRING253=(IToken)Match(input,STRING,FOLLOW_STRING_in_note3156);  
            	stream_STRING.Add(STRING253);



            	// AST REWRITE
            	// elements:          STRING
            	// token labels:      
            	// rule labels:       retval
            	// token list labels: 
            	// rule list labels:  
            	// wildcard labels: 
            	retval.Tree = root_0;
            	RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(adaptor, "rule retval", retval!=null ? retval.Tree : null);

            	root_0 = (CommonTree)adaptor.GetNilNode();
            	// 408:19: -> ^( STRING )
            	{
            	    // C:\\Users\\Isabella\\Documents\\SwimmingCompetitionGrammar.g:408:22: ^( STRING )
            	    {
            	    CommonTree root_1 = (CommonTree)adaptor.GetNilNode();
            	    root_1 = (CommonTree)adaptor.BecomeRoot(new SwimmingCompetition.AST.NoteNode(stream_STRING.NextToken()), root_1);

            	    adaptor.AddChild(root_0, root_1);
            	    }

            	}

            	retval.Tree = root_0;retval.Tree = root_0;
            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (CommonTree)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        throw new ErrorNodeException("", "NOTE");
        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR end "note"

    // Delegated rules


	private void InitializeCyclicDFAs()
	{
	}

 

    public static readonly BitSet FOLLOW_EVENT_in_s1088 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_s1090 = new BitSet(new ulong[]{0x0000000000000020UL});
    public static readonly BitSet FOLLOW_infocompetition_in_s1092 = new BitSet(new ulong[]{0x0000000000100000UL});
    public static readonly BitSet FOLLOW_jurycronoother_in_s1094 = new BitSet(new ulong[]{0x0000000400000000UL});
    public static readonly BitSet FOLLOW_programcomp_in_s1096 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000008UL});
    public static readonly BitSet FOLLOW_startlist_in_s1098 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000080UL});
    public static readonly BitSet FOLLOW_note_in_s1100 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_C_GR_in_s1102 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_INFOEVENT_in_infocompetition1137 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_infocompetition1140 = new BitSet(new ulong[]{0x0000000000000040UL});
    public static readonly BitSet FOLLOW_nameevent_in_infocompetition1144 = new BitSet(new ulong[]{0x0000000000000080UL});
    public static readonly BitSet FOLLOW_category_in_infocompetition1147 = new BitSet(new ulong[]{0x0000000000000800UL});
    public static readonly BitSet FOLLOW_organiz_in_infocompetition1150 = new BitSet(new ulong[]{0x0000000000001000UL});
    public static readonly BitSet FOLLOW_location_in_infocompetition1153 = new BitSet(new ulong[]{0x0000000000002000UL});
    public static readonly BitSet FOLLOW_type_in_infocompetition1156 = new BitSet(new ulong[]{0x0000000000004000UL});
    public static readonly BitSet FOLLOW_start_in_infocompetition1159 = new BitSet(new ulong[]{0x0000000000008000UL});
    public static readonly BitSet FOLLOW_end_in_infocompetition1162 = new BitSet(new ulong[]{0x0000000000010000UL});
    public static readonly BitSet FOLLOW_enddatereg_in_infocompetition1165 = new BitSet(new ulong[]{0x0000000000020000UL});
    public static readonly BitSet FOLLOW_poolbase_in_infocompetition1168 = new BitSet(new ulong[]{0x0000000000040000UL});
    public static readonly BitSet FOLLOW_limittimereg_in_infocompetition1171 = new BitSet(new ulong[]{0x0000000000080000UL});
    public static readonly BitSet FOLLOW_lanes_in_infocompetition1174 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_C_GR_in_infocompetition1177 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NAMEEVENT_in_nameevent1224 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_nameevent1226 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_nameevent1228 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CATEGORY_in_category1249 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_category1252 = new BitSet(new ulong[]{0x0000000000000700UL});
    public static readonly BitSet FOLLOW_categorySigleComp_in_category1255 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ORGANIZ_in_organiz1262 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_organiz1264 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_organiz1266 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LOCATION_in_location1286 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_location1288 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_location1290 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPE_in_type1310 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_type1312 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_type1314 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_START_in_start1334 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_start1336 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_DATE_in_start1338 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_END_in_end1358 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_end1360 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_DATE_in_end1361 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ENDDATEREG_in_enddatereg1383 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_enddatereg1385 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_DATE_in_enddatereg1387 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_POOLBASE_in_poolbase1406 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_poolbase1408 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_INT_in_poolbase1410 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000400000000UL});
    public static readonly BitSet FOLLOW_98_in_poolbase1412 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LIMITTIMEREG_in_limittimereg1434 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_limittimereg1436 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_limittimereg1438 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_LANES_in_lanes1458 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_lanes1460 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_INT_in_lanes1462 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_catSA_in_categorySigleComp1483 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_catSM_in_categorySigleComp1485 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_catSP_in_categorySigleComp1487 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CATA_in_catSA1495 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CATM_in_catSM1509 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CATP_in_catSP1523 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_jury_in_jurycronoother1540 = new BitSet(new ulong[]{0x0000000004000000UL});
    public static readonly BitSet FOLLOW_crono_in_jurycronoother1542 = new BitSet(new ulong[]{0x0000000040000000UL});
    public static readonly BitSet FOLLOW_other_in_jurycronoother1544 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_JURY_in_jury1556 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_jury1559 = new BitSet(new ulong[]{0x0000000000200000UL});
    public static readonly BitSet FOLLOW_referee_in_jury1563 = new BitSet(new ulong[]{0x0000000000C00000UL});
    public static readonly BitSet FOLLOW_coadjuctor_in_jury1567 = new BitSet(new ulong[]{0x0000000000C00000UL});
    public static readonly BitSet FOLLOW_depjudge_in_jury1572 = new BitSet(new ulong[]{0x0000000003000000UL});
    public static readonly BitSet FOLLOW_falsestartempl_in_jury1576 = new BitSet(new ulong[]{0x0000000003000000UL});
    public static readonly BitSet FOLLOW_compempl_in_jury1581 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_C_GR_in_jury1584 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_REFEREE_in_referee1636 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_referee1638 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_referee1640 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_COADJUTOR_in_coadjuctor1662 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_coadjuctor1664 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_coadjuctor1666 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DEPJUDGE_in_depjudge1689 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_depjudge1692 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_depjudge1694 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FALSESTARTEMPL_in_falsestartempl1716 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_falsestartempl1718 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_falsestartempl1720 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_COMPEMPL_in_compempl1742 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_compempl1744 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_compempl1746 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TIMING_in_crono1770 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_crono1773 = new BitSet(new ulong[]{0x0000000008000000UL});
    public static readonly BitSet FOLLOW_cronotype_in_crono1777 = new BitSet(new ulong[]{0x0000000010000000UL});
    public static readonly BitSet FOLLOW_cronoserv_in_crono1780 = new BitSet(new ulong[]{0x0000000020000000UL});
    public static readonly BitSet FOLLOW_cronosoc_in_crono1783 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_C_GR_in_crono1786 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CRONOTYPE_in_cronotype1824 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_cronotype1826 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_cronotype1828 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CRONOSERV_in_cronoserv1849 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_cronoserv1851 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_cronoserv1853 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CRONOSOC_in_cronosoc1872 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_cronosoc1874 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_cronosoc1876 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OTHER_in_other1900 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_other1903 = new BitSet(new ulong[]{0x0000000080000000UL});
    public static readonly BitSet FOLLOW_speak_in_other1907 = new BitSet(new ulong[]{0x0000000100000000UL});
    public static readonly BitSet FOLLOW_doct_in_other1910 = new BitSet(new ulong[]{0x0000000200000000UL});
    public static readonly BitSet FOLLOW_manag_in_other1913 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_C_GR_in_other1916 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_SPEAK_in_speak1952 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_speak1954 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_speak1957 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DOCT_in_doct1977 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_doct1979 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_doct1982 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_MANAG_in_manag2002 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_manag2004 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_manag2006 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_PROG_in_programcomp2030 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_programcomp2033 = new BitSet(new ulong[]{0x0000000800000000UL});
    public static readonly BitSet FOLLOW_programSingleDay_in_programcomp2037 = new BitSet(new ulong[]{0x0000000800000000UL,0x0000000000010000UL});
    public static readonly BitSet FOLLOW_C_GR_in_programcomp2042 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_DATECOMP_in_programSingleDay2079 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_programSingleDay2081 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_DATE_in_programSingleDay2083 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_programSingleDay2086 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_competition_in_programSingleDay2092 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000030000UL});
    public static readonly BitSet FOLLOW_C_GR_in_programSingleDay2097 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_A_Q_in_competition2130 = new BitSet(new ulong[]{0x0000001000000000UL});
    public static readonly BitSet FOLLOW_hourcomp_in_competition2133 = new BitSet(new ulong[]{0x0000002000000000UL});
    public static readonly BitSet FOLLOW_categorycomp_in_competition2136 = new BitSet(new ulong[]{0x4000000000000000UL});
    public static readonly BitSet FOLLOW_speccomp_in_competition2139 = new BitSet(new ulong[]{0x8000000000000000UL});
    public static readonly BitSet FOLLOW_turncomp_in_competition2142 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000040000UL});
    public static readonly BitSet FOLLOW_C_Q_in_competition2145 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_HOURCOMP_in_hourcomp2168 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_hourcomp2170 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000002000000UL});
    public static readonly BitSet FOLLOW_HOUR_in_hourcomp2172 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CATEGORYCOMP_in_categorycomp2193 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_categorycomp2196 = new BitSet(new ulong[]{0x3FFFFFC000000000UL});
    public static readonly BitSet FOLLOW_categorySingleComp_in_categorycomp2199 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_SPECCOMP_in_speccomp2205 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_speccomp2207 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_speccomp2209 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TURNCOMP_in_turncomp2228 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_turncomp2231 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000007UL});
    public static readonly BitSet FOLLOW_typeturncomp_in_turncomp2234 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typeesa_in_categorySingleComp2246 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typeesb_in_categorySingleComp2250 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typep1_in_categorySingleComp2253 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typep2_in_categorySingleComp2257 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typep3_in_categorySingleComp2260 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typep4_in_categorySingleComp2263 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typep5_in_categorySingleComp2266 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typep6_in_categorySingleComp2269 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typep7_in_categorySingleComp2272 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typer_in_categorySingleComp2275 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typej_in_categorySingleComp2279 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typec_in_categorySingleComp2283 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_types_in_categorySingleComp2287 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typeabs_in_categorySingleComp2291 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typeu25_in_categorySingleComp2295 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typem25_in_categorySingleComp2301 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typem30_in_categorySingleComp2304 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typem35_in_categorySingleComp2308 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typem40_in_categorySingleComp2312 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typem45_in_categorySingleComp2316 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typem50_in_categorySingleComp2320 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typem55_in_categorySingleComp2324 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typem60_in_categorySingleComp2328 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typem65_in_categorySingleComp2332 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEESA_in_typeesa2340 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEESB_in_typeesb2354 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEP1_in_typep12368 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEP2_in_typep22382 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEP3_in_typep32396 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEP4_in_typep42410 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEP5_in_typep52424 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEP6_in_typep62438 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEP7_in_typep72452 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPER_in_typer2466 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEJ_in_typej2480 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEC_in_typec2495 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPES_in_types2509 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEABS_in_typeabs2523 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEU25_in_typeu252537 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEM25_in_typem252551 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEM30_in_typem302565 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEM35_in_typem352579 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEM40_in_typem402593 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEM45_in_typem452607 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEM50_in_typem502621 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEM55_in_typem552635 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEM60_in_typem602649 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_TYPEM65_in_typem652663 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_heats_in_typeturncomp2681 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_fin_in_typeturncomp2685 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_semfin_in_typeturncomp2689 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_HEATS_in_heats2699 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_FIN_in_fin2715 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_SEMFIN_in_semfin2732 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_STARTLIST_in_startlist2752 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_startlist2755 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000010UL});
    public static readonly BitSet FOLLOW_singlecomp_in_startlist2760 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010010UL});
    public static readonly BitSet FOLLOW_C_GR_in_startlist2765 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_COMPNAME_in_singlecomp2797 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_singlecomp2799 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_singlecomp2801 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_singlecomp2805 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000007UL});
    public static readonly BitSet FOLLOW_turn_in_singlecomp2810 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000010007UL});
    public static readonly BitSet FOLLOW_C_GR_in_singlecomp2815 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_nameturn_in_turn2847 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000008000UL});
    public static readonly BitSet FOLLOW_A_GR_in_turn2850 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_startathlete_in_turn2854 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000030000UL});
    public static readonly BitSet FOLLOW_C_GR_in_turn2859 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_typeturncomp_in_nameturn2881 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_INT_in_nameturn2883 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_A_Q_in_startathlete2908 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_LANE_in_startathlete2912 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_startathlete2914 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000400000UL});
    public static readonly BitSet FOLLOW_INT_in_startathlete2916 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000100UL});
    public static readonly BitSet FOLLOW_athlete_in_startathlete2920 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000040000UL});
    public static readonly BitSet FOLLOW_C_Q_in_startathlete2924 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_acode_in_athlete2951 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000200UL});
    public static readonly BitSet FOLLOW_aname_in_athlete2954 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000400UL});
    public static readonly BitSet FOLLOW_asurname_in_athlete2957 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000800UL});
    public static readonly BitSet FOLLOW_asoc_in_athlete2960 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000001000UL});
    public static readonly BitSet FOLLOW_abirth_in_athlete2963 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000002000UL});
    public static readonly BitSet FOLLOW_atimereg_in_athlete2966 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000004000UL});
    public static readonly BitSet FOLLOW_atimeres_in_athlete2969 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ACODE_in_acode2980 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_acode2982 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_acode2984 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ANAME_in_aname3004 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_aname3006 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_aname3008 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ASURNNAME_in_asurname3027 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_asurname3029 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_asurname3031 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ASOC_in_asoc3051 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_asoc3053 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_asoc3055 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ABIRTH_in_abirth3076 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_abirth3078 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000001000000UL});
    public static readonly BitSet FOLLOW_DATE_in_abirth3080 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ATIMEREG_in_atimereg3099 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_atimereg3101 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000200000UL});
    public static readonly BitSet FOLLOW_ATIME_in_atimereg3103 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ATIMERES_in_atimeres3122 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_atimeres3124 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000200000UL});
    public static readonly BitSet FOLLOW_ATIME_in_atimeres3126 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_NOTES_in_note3152 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000200000000UL});
    public static readonly BitSet FOLLOW_97_in_note3154 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000008000000UL});
    public static readonly BitSet FOLLOW_STRING_in_note3156 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}